README

kmdgo

I created this Go package as part of my learning process of Go language. This as of this stage is working to for the basic things required, like just using the "methods" with "parameters" and it will give you the expected result in Go's native data set, structs, which you can use further to code your application. Would really appreciate if any other experienced Go language developers may push any improvements of fixes required for this package.

As of this stage, this package is compatible with Komodo and all of it's Assetchains.

Documentation and Examples

Install dependencies and setup environemnt

This package depends on saplinglib, so you have to get that package and set environment variables.

For Linux setup these environment variables:

export CGO_CFLAGS="-I$HOME/go/src/github.com/satindergrewal/saplinglib/src/"
export CGO_LDFLAGS="-L$HOME/go/src/github.com/satindergrewal/saplinglib/dist/linux -lsaplinglib -lpthread -ldl -lm"

For MacOS setup these environment variables:

export CGO_CFLAGS="-I$HOME/go/src/github.com/satindergrewal/saplinglib/src/"
export CGO_LDFLAGS="-L$HOME/go/src/github.com/satindergrewal/saplinglib/dist/darwin -lsaplinglib -framework Security"

For MingW cross-platform windows setup these environment variables:

export CGO_CFLAGS="-I$HOME/go/src/github.com/satindergrewal/saplinglib/src/"
export CGO_LDFLAGS="-L$HOME/go/src/github.com/satindergrewal/saplinglib/dist/win64 -lsaplinglib -lws2_32 -luserenv"
export CC="x86_64-w64-mingw32-gcc"

Install dependency:

go get -u github.com/satindergrewal/saplinglib
Quick Example

To use this package do

go get -u github.com/satindergrewal/kmdgo

Example code:

//main.go
package main

import (
	"fmt"
	"github.com/satindergrewal/kmdgo/kmdutil"
)

func main() {
	appName := "VRSC"
	dir := kmdutil.AppDataDir(appName, false)
	fmt.Println(dir)

	rpcuser, rpcpass, rpcport := kmdutil.AppRPCInfo(appName)
	fmt.Printf("RPC User: %s\nRPC Password: %s\nRPC Port: %s\n", rpcuser, rpcpass, rpcport)
}

Output:

$ go run main.go
/home/satinder/.komodo/VRSC
RPC User: user1773837506
RPC Password: passbae43ecd576o8ariotkgjhasdfiyosidulrkhdf9390bf03b68
RPC Port: 27486

Supported API Calls

KMDUtil Specific Methods
  • AppDataDir - Gives the path of cryptocurrency's Data directory based on it's symbol. Supports Only Komodo and Assetchains so far.
  • AppRPCInfo - Provides RPC username, password and it's port by reading it's config file from data directory.
  • GetTAddress - GetTAddress generates a public address using a seed phrase
  • GetZAddress - GetZAddress generates a shielded sapling address using a seed phrase
  • GetIguanaWallet - GetIguanaWallet returns a set of public and shielded addresses generated based on a mnemonic seed phrase
  • BytesToString - BytesToString converts and returns bytes to string
NOTE: saplinglib is required for kmdutil methods GetZAddress and GetIguanaWallet
CClib
  • cclib method [evalcode] [JSON params]
  • cclibaddress [evalcode] [pubkey]
  • cclibinfo
DEX
  • DEX_anonsend message priority destpub33
  • DEX_broadcast hex [priority [tagA [tagB [pubkey33 [volA [volB]]]]]]
  • DEX_cancel id [pubkey33 [tagA tagB]]
  • DEX_get id
  • DEX_list stopat minpriority tagA tagB pubkey33 [minA maxA minB maxB [stophash]]
  • DEX_notarize coin height
  • DEX_orderbook maxentries minpriority tagA tagB pubkey33 [minA maxA minB maxB]
  • DEX_publish filename priority sliceid
  • DEX_setpubkey pubkey33
  • DEX_stats
  • DEX_stream filename priority
  • DEX_streamsub filename priority pubkey
  • DEX_subscribe filename priority id [publisher33]
FSM
  • FSMaddress [pubkey]
  • FSMcreate name states
  • FSMinfo fundingtxid
  • FSMlist
Addressindex
  • getaddressbalance
  • getaddressdeltas
  • getaddressmempool
  • getaddresstxids
  • getaddressutxos
  • getsnapshot
Auction
  • auctionaddress [pubkey]
Blockchain
  • coinsupply
  • getbestblockhash
  • getblock "hash|height" ( verbosity )
  • getblockchaininfo
  • getblockcount
  • getblockhash index
  • getblockhashes timestamp -- Todo
  • getblockheader "hash" ( verbose )
  • getchaintips
  • getdifficulty
  • getmempoolinfo
  • getrawmempool ( verbose )
  • getspentinfo -- Todo
  • gettxout "txid" n ( includemempool )
  • gettxoutproof ["txid",...] ( blockhash )
  • gettxoutsetinfo
  • kvsearch key -- Todo
  • kvupdate key "value" days passphrase -- Todo
  • minerids needs height
  • notaries height timestamp
  • verifychain ( checklevel numblocks )
  • verifytxoutproof "proof"
Channels
  • channelsaddress destpubkey
  • channelsclose opentxid
  • channelsinfo [opentxid]
  • channelsinfo
  • channelsopen destpubkey numpayments payment
  • channelspayment opentxid amount [secret]
  • channelsrefund opentxid closetxid
Control
  • getinfo
  • help ( "command" )
  • stop
Crosschain
  • MoMoMdata symbol kmdheight ccid
  • assetchainproof needs a txid
  • calc_MoM height MoMdepth
  • getNotarisationsForBlock blockHash
  • height_MoM height
  • migrate_completeimporttransaction importTx
  • migrate_converttoexport rawTx dest_symbol export_amount
  • migrate_createimporttransaction burnTx payouts
  • scanNotarisationsDB blockHeight symbol [blocksLimit=1440]
Dice
  • diceaddfunds name fundingtxid amount
  • diceaddress [pubkey]
  • dicebet name fundingtxid amount odds
  • dicefinish name fundingtxid bettxid
  • dicefund name funds minbet maxbet maxodds timeoutblocks
  • diceinfo fundingtxid
  • dicelist
  • dicestatus name fundingtxid bettxid
Disclosure
  • z_getpaymentdisclosure "txid" "js_index" "output_index" ("message")
  • z_validatepaymentdisclosure "paymentdisclosure"
Faucet
  • faucetaddress [pubkey]
  • faucetfund amount
  • faucetget
  • faucetinfo
Rogue Game
  • cclib newgame [evalcode] "[maxplayers, buyin]"
  • cclib gameinfo [evalcode] "[gametxid]"
  • cclib pending [evalcode]
  • cclib register [evalcode] "[gametxid, [playertxid]]"
  • cclib keystrokes [evalcode] "[gametxid, keystrokes]" -- This is only executed by the ROGUE dApp. Not need to run manully
  • cclib bailout [evalcode] "[gametxid]"
  • cclib highlander [evalcode] "[gametxid]"
  • cclib playerinfo [evalcode] "[playertxid]"
  • cclib players [evalcode]
  • cclib games [evalcode]
  • cclib setname [evalcode] "[pname]"
Gateways
  • gatewaysaddress [pubkey]
  • gatewaysbind tokenid oracletxid coin tokensupply M N pubkey(s)
  • gatewaysclaim bindtxid coin deposittxid destpub amount
  • gatewayscompletesigning withdrawtxid coin hex
  • gatewaysdeposit bindtxid height coin cointxid claimvout deposithex proof destpub amount
  • gatewaysinfo bindtxid
  • gatewayslist
  • gatewaysmarkdone completesigningtx coin
  • gatewaysmultisig txidaddr
  • gatewayspartialsign txidaddr refcoin hex
  • gatewayspending bindtxid coin
  • gatewaysprocessed bindtxid coin
  • gatewayswithdraw bindtxid coin withdrawpub amount
Generating
  • generate numblocks
  • getgenerate
  • setgenerate generate ( genproclimit )
Heir
  • heiraddress func txid amount [destpubkey]
Lotto
  • lottoaddress [pubkey]
Mining
  • getblocksubsidy height
  • getblocktemplate ( "jsonrequestobject" )
  • getlocalsolps
  • getmininginfo
  • getnetworkhashps ( blocks height )
  • getnetworksolps ( blocks height )
  • prioritisetransaction
  • submitblock "hexdata" ( "jsonparametersobject" )
Network
  • addnode "node" "add|remove|onetry"
  • clearbanned
  • disconnectnode "node"
  • getaddednodeinfo dns ( "node" )
  • getconnectioncount
  • getdeprecationinfo
  • getnettotals
  • getnetworkinfo
  • getpeerinfo
  • listbanned
  • ping
  • setban "ip(/netmask)" "add|remove" (bantime) (absolute)
Oracles
  • oraclesaddress [pubkey]
  • oraclescreate name description format
  • oraclesdata oracletxid hexstr
  • oraclesinfo oracletxid
  • oracleslist
  • oraclesregister oracletxid datafee
  • oraclessamples oracletxid batonutxo num
  • oraclessubscribe oracletxid publisher amount
Payments
  • paymentsaddress [pubkey]
Pegs
  • pegssaddress [pubkey]
Prices
  • pricesaddfunding fundingtxid bettoken amount
  • pricesaddress [pubkey]
  • pricesbet fundingtxid bettoken amount leverage
  • pricescreate bettoken oracletxid margin mode longtoken shorttoken maxleverage funding N [pubkeys]
  • pricesfinish fundingtxid bettoken bettxid
  • pricesinfo fundingtxid
  • priceslist
  • pricesstatus fundingtxid bettoken bettxid
Rawtransactions
  • createrawtransaction [{"txid":"id","vout":n},...] {"address":amount,...} ( locktime ) ( expiryheight )
  • decoderawtransaction "hexstring"
  • decodescript "hex"
  • fundrawtransaction "hexstring"
  • getrawtransaction "txid" ( verbose )
  • sendrawtransaction "hexstring" ( allowhighfees )
  • signrawtransaction "hexstring" ( [{"txid":"id","vout":n,"scriptPubKey":"hex","redeemScript":"hex"},...] ["privatekey1",...] sighashtype )
Rewards
  • rewardsaddfunding name fundingtxid amount
  • rewardsaddress [pubkey]
  • rewardscreatefunding name amount APR mindays maxdays mindeposit
  • rewardsinfo fundingtxid
  • rewardslist
  • rewardslock name fundingtxid amount
  • rewardsunlock name fundingtxid [txid]
Tokens
  • tokenaddress [pubkey]
  • tokenask numtokens tokenid price
  • tokenbalance tokenid [pubkey]
  • tokenbid numtokens tokenid price
  • tokencancelask tokenid asktxid
  • tokencancelbid tokenid bidtxid
  • tokenconvert evalcode tokenid pubkey amount
  • tokencreate name supply description
  • tokenfillask tokenid asktxid fillunits
  • tokenfillbid tokenid bidtxid fillamount
  • tokeninfo tokenid
  • tokenlist
  • tokenorders [tokenid]
  • tokentransfer tokenid destpubkey amount
Triggers
  • triggersaddress [pubkey]
Util
  • createmultisig nrequired ["key",...]
  • estimatefee nblocks
  • estimatepriority nblocks
  • invalidateblock "hash"
  • jumblr_deposit "depositaddress"
  • jumblr_pause
  • jumblr_resume
  • jumblr_secret "secretaddress"
  • reconsiderblock "hash"
  • txnotarizedconfirmed txid
  • validateaddress "komodoaddress"
  • verifymessage "komodoaddress" "signature" "message"
  • z_validateaddress "zaddr"
Wallet
  • addmultisigaddress nrequired ["key",...] ( "account" )
  • backupwallet "destination"
  • dumpprivkey "t-addr"
  • dumpwallet "filename"
  • encryptwallet "passphrase"
  • getaccount "KMD_address"
  • getaccountaddress "account"
  • getaddressesbyaccount "account"
  • getbalance ( "account" minconf includeWatchonly )
  • getnewaddress ( "account" )
  • getrawchangeaddress
  • getreceivedbyaccount "account" ( minconf )
  • getreceivedbyaddress "KMD_address" ( minconf )
  • gettransaction "txid" ( includeWatchonly )
  • getunconfirmedbalance
  • getwalletinfo
  • importaddress "address" ( "label" rescan )
  • importprivkey "komodoprivkey" ( "label" rescan )
  • importwallet "filename"
  • keypoolrefill ( newsize )
  • listaccounts ( minconf includeWatchonly)
  • listaddressgroupings
  • listlockunspent
  • listreceivedbyaccount ( minconf includeempty includeWatchonly) -- DEPRECATED
  • listreceivedbyaddress ( minconf includeempty includeWatchonly)
  • listsinceblock ( "blockhash" target-confirmations includeWatchonly)
  • listtransactions ( "account" count from includeWatchonly)
  • listunspent ( minconf maxconf ["address",...] )
  • lockunspent unlock [{"txid":"txid","vout":n},...]
  • move "fromaccount" "toaccount" amount ( minconf "comment" ) -- DEPRECATED
  • resendwallettransactions -- "Intended only for testing;" --- May be Later --- Todo
  • sendfrom "fromaccount" "toKMDaddress" amount ( minconf "comment" "comment-to" )
  • sendmany "fromaccount" {"address":amount,...} ( minconf "comment" ["address",...] )
  • sendtoaddress "KMD_address" amount ( "comment" "comment-to" subtractfeefromamount )
  • setaccount "KMD_address" "account" -- DEPRECATED
  • setpubkey
  • settxfee amount
  • signmessage "t-addr" "message"
  • walletlock
  • walletpassphrase "passphrase" seconds
  • walletpassphrasechange "oldpassphrase" "newpassphrase"
  • z_exportkey "zaddr"
  • z_exportviewingkey "zaddr"
  • z_exportwallet "filename"
  • z_getbalance "address" ( minconf )
  • z_getnewaddress ( type )
  • z_getoperationresult (["operationid", ... ])
  • z_getoperationstatus (["operationid", ... ])
  • z_gettotalbalance ( minconf includeWatchonly )
  • z_importkey "zkey" ( rescan startHeight )
  • z_importviewingkey "vkey" ( rescan startHeight )
  • z_importwallet "filename"
  • z_listaddresses ( includeWatchonly )
  • z_listoperationids
  • z_listreceivedbyaddress "address" ( minconf )
  • z_listunspent ( minconf maxconf includeWatchonly ["zaddr",...] )
  • z_mergetoaddress ["fromaddress", ... ] "toaddress" ( fee ) ( transparent_limit ) ( shielded_limit ) ( memo )
  • z_sendmany "fromaddress" [{"address":... ,"amount":...},...] ( minconf ) ( fee )
  • z_shieldcoinbase "fromaddress" "tozaddress" ( fee ) ( limit )
  • zcbenchmark benchmarktype samplecount -- Todo
  • zcrawjoinsplit rawtx inputs outputs vpub_old vpub_new -- Todo
  • zcrawkeygen -- Todo
  • zcrawreceive zcsecretkey encryptednote -- Todo
  • zcsamplejoinsplit -- Todo

Verus blockchain specific Methods

Verus Identity
  • getidentity "name"
  • listidentities (includecansign) (includewatchonly)
  • recoveridentity "jsonidentity" (returntx)
  • registeridentity "jsonidregistration" feeoffer
  • registernamecommitment "name" "controladdress" ("referralidentity")
  • revokeidentity "nameorID" (returntx)
  • updateidentity "jsonidentity" (returntx)
Verus Multichain
  • addmergedblock "hexdata" ( "jsonparametersobject" )
  • definecurrency '{"name": "BAAS", ..., "nodes":[{"networkaddress":"identity"},..]}'
  • getcrossnotarization "systemid" '["notarizationtxid1", "notarizationtxid2", ...]' - TODO - Need example command/output
  • getcurrency "chainname"
  • getcurrencyconverters ["currency1","currency2",...]'
  • getcurrencystate "n"
  • getexports "chainname"
  • getimports "chainname"
  • getinitialcurrencystate "name"
  • getlastimportin "fromname"
  • getlatestimportsout "name" "lastimporttransaction" "importtxtemplate" - TODO - Need example command/output
  • getblocktemplate ( "jsonrequestobject" ) - TODO - Need example command/output
  • getnotarizationdata "currencyid" accepted
  • getpendingtransfers "chainname" - TODO - need example output
  • getsaplingtree "n" - TODO - Need example command/output
  • listcurrencies (includeexpired)
  • paynotarizationrewards "currencyid" "amount" "billingperiod"
  • refundfailedlaunch "currencyid" - TODO - need example output
  • reserveexchange '[{"toreserve": 1, "recipient": "RRehdmUV7oEAqoZnzEGBH34XysnWaBatct", "amount": 5.0}]'
  • sendcurrency "fromaddress" '[{"address":... ,"amount":...},...]' (returntx)
  • submitacceptednotarization "hextx"
Verus Wallet
  • convertpassphrase "walletpassphrase"
  • signfile "address or identity" "filepath/filename" "curentsig"
  • z_getmigrationstatus
  • z_setmigration enabled
  • z_viewtransaction "txid"

Documentation

Index

Constants

View Source
const KMDGoVersion = `0.1.0`

    KMDGoVersion records the version of KMD Go package

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type APIParams

    type APIParams []interface{}

      APIParams holds the set of parameters passed along methods to smart chain RPC API queries

      type APIQuery

      type APIQuery struct {
      	Method string `json:"method"`
      	Params string `json:"params"`
      }

        APIQuery holds the methods and params which is sent with body of RPC API queries

        type APIResult

        type APIResult struct {
        	Result interface{} `json:"result"`
        	Error  interface{} `json:"error"`
        	ID     string      `json:"id"`
        }

          APIResult data type for holding returned results of API queries

          type AddMultiSigAddress

          type AddMultiSigAddress struct {
          	Result string `json:"result"`
          	Error  Error  `json:"error"`
          	ID     string `json:"id"`
          }

          type AddNode

          type AddNode struct {
          	Result string `json:"result"`
          	Error  Error  `json:"error"`
          	ID     string `json:"id"`
          }

          type AppType

          type AppType string

            AppType holds the smart chain's name

            func NewAppType

            func NewAppType(app AppType) *AppType

              NewAppType returns the smart chain as variable type AppType

              func (AppType) APICall

              func (appName AppType) APICall(q *APIQuery) string

                APICall executes the blockchain RPC Calls and returns the data in JSON output. By default this API call tries to get the RPC information from the .conf file from the set blockchain's default directory on the system based on OS which is being executed on. If the local system doesn't has the blockchain running, you can also set this RPC settings in environment variables. The environment variable has to use the the combination of the appName + _RPCURL. Shell example: export komodo_RPCURL="http://192.168.1.1:" export komodo_RPCUSER="username" export komodo_RPCPASS="password" export komodo_RPCPORT="7771"

                These environment variables can also be set within Go code. Example: os.Setenv("komodo" + "_RPCURL", `http://127.0.0.1:`) os.Setenv("komodo" + "_RPCUSER", `username`) os.Setenv("komodo" + "_RPCPASS", `password`) os.Setenv("komodo" + "_RPCPORT", `7771`)

                As per this example, if for example using different SmartChain like "DEX", and the appName is set to example "DEX", just replace it word `komodo` with `DEX`.

                func (AppType) AddMultiSigAddress

                func (appName AppType) AddMultiSigAddress(params APIParams) (AddMultiSigAddress, error)

                func (AppType) AddNode

                func (appName AppType) AddNode(params APIParams) (AddNode, error)

                func (AppType) BackupWallet

                func (appName AppType) BackupWallet(bkpwlt string) (BackupWallet, error)

                func (AppType) CCLibAddress

                func (appName AppType) CCLibAddress(params APIParams) (CCLibAddress, error)

                  CCLibAddress method returns information about the addresses related to the specified pubkey, and according to the Antara Module associated with the specified evalcode. If no pubkey is provided, the pubkey used to the launch the daemon is the default.

                  func (AppType) CCLibInfo

                  func (appName AppType) CCLibInfo() (CCLibInfo, error)

                    CCLibInfo method displays all the methods of all the modules that are available in the current library. The library is loaded at runtime using the -ac_cclib parameter.

                    func (AppType) ClearBanned

                    func (appName AppType) ClearBanned() (ClearBanned, error)

                    func (AppType) CoinSupply

                    func (appName AppType) CoinSupply(params APIParams) (CoinSupply, error)

                      CoinSupply method returns the coin supply information for the indicated block height. If no height is given, the method defaults to the blockchain's current height.

                      func (AppType) CreateRawTransaction

                      func (appName AppType) CreateRawTransaction(params APIParams) (CreateRawTransaction, error)

                      func (AppType) DEXAnonsend

                      func (appName AppType) DEXAnonsend(params APIParams) (DEXAnonsend, error)

                        DEXAnonsend This method can be used by a user to broadcast any message to the p2p network without revealing either the DEX_pubkeys involved or the contents of the message to the network. The datablob so created will be added to the "Data Mempools" of all the nodes with the parameter -dexp2p set to 1 or 2, but can only be decrypted by the node whose DEX_pubkey is destpub33. The recipient node can also see the DEX_pubkey of the sender.

                        func (AppType) DEXBroadcast

                        func (appName AppType) DEXBroadcast(params APIParams) (DEXBroadcast, error)

                          DEXBroadcast method can be used to broadcast any data to the p2p network, which will be added to the "Data Mempools" of all the nodes with the parameter -dexp2p set to 1 or 2.

                          func (AppType) DEXCancel

                          func (appName AppType) DEXCancel(params APIParams) (DEXCancel, error)

                            DEXCancel This method can be used to cancel an order issued by the user's node. A node can cancel only the orders that were broadcasted using its current DEX_pubkey. Orders that are broadcasted without being authenticated by a pubkey can not be canceled.

                            func (AppType) DEXGet

                            func (appName AppType) DEXGet(params APIParams) (DEXGet, error)

                              DEXGet method returns an order's data by its id.

                              func (AppType) DEXList

                              func (appName AppType) DEXList(params APIParams) (DEXList, error)

                                DEXList method can be used to filter and list data from the "Data Mempool" of the node. Each specified filter narrows the list down to the datablobs that match it exactly. If a filter is specified as "" or 0, it matches all the values a datablob might have for the filter.

                                func (AppType) DEXOrderbook

                                func (appName AppType) DEXOrderbook(params APIParams) (DEXOrderbook, error)

                                  DEXOrderbook method interprets the datablobs as orders for AtomicDEX and displays relevant data for each order that matches the filters applied through the parameters.

                                  func (AppType) DEXPublish

                                  func (appName AppType) DEXPublish(params APIParams) (DEXPublish, error)

                                    DEXPublish method allows user to publish file to p2p network. By default it looks for the file in followin directories based on different OS: Linux: $HOME directory path = $HOME/dexp2p = example: /home/satinder Mac: $HOME directory path = $HOME/dexp2p = example: /Users/satinder Windows: %AppData% directory path = %AppData%\dexp2p = example: C:\Users\satinder\AppData\dexp2p

                                    func (AppType) DEXSetPubKey

                                    func (appName AppType) DEXSetPubKey(params APIParams) (DEXSetPubKey, error)

                                      DEXSetPubKey sets the public key for blockchain in case it is not started with already a pubkey with paramater `-pubkey=` at it's daemon start. This method will only set the public key once. Once set, and in case this pubkey needs to be changed, the daemon must be restarted. It is a pubkey value which is also displayed in output to method "validateaddress".

                                      func (AppType) DEXStats

                                      func (appName AppType) DEXStats() (DEXStats, error)

                                        DEXStats method gives info and stats related to the p2p data layer.

                                        func (AppType) DecodeRawTransaction

                                        func (appName AppType) DecodeRawTransaction(params APIParams) (DecodeRawTransaction, error)

                                        func (AppType) DecodeScript

                                        func (appName AppType) DecodeScript(params APIParams) (DecodeScript, error)

                                        func (AppType) DisconnectNode

                                        func (appName AppType) DisconnectNode(node string) (DisconnectNode, error)

                                        func (AppType) DumpPrivKey

                                        func (appName AppType) DumpPrivKey(taddr string) (DumpPrivKey, error)

                                        func (AppType) DumpWallet

                                        func (appName AppType) DumpWallet(dmpwlt string) (DumpWallet, error)

                                        func (AppType) EncryptWallet

                                        func (appName AppType) EncryptWallet(phrase string) (EncryptWallet, error)

                                        func (AppType) FaucetAddress

                                        func (appName AppType) FaucetAddress(params APIParams) (FaucetAddress, error)

                                          FaucetAddress method returns the Antara address information for the specified pubkey. If no pubkey is provided, the method returns information for the pubkey used to launch the daemon

                                          func (AppType) FaucetFund

                                          func (appName AppType) FaucetFund(params APIParams) (FaucetFund, error)

                                            FaucetFund method funds the on-chain faucet. The method returns a hex value which must then be broadcast using the sendrawtransaction method

                                            func (AppType) FaucetGet

                                            func (appName AppType) FaucetGet() (FaucetGet, error)

                                              FaucetGet method requests the faucet module to send coins. The method returns a hex value which must then be broadcast using the sendrawtransaction method. The faucetget command yields 0.1 coins and requires about 30 seconds of CPU time to execute

                                              func (AppType) FaucetInfo

                                              func (appName AppType) FaucetInfo() (FaucetInfo, error)

                                                FaucetInfo method displays the balance of funds in the chain's faucet.

                                                func (AppType) FundRawTransaction

                                                func (appName AppType) FundRawTransaction(params APIParams) (FundRawTransaction, error)

                                                func (AppType) GetAccount

                                                func (appName AppType) GetAccount(taddr string) (GetAccount, error)

                                                func (AppType) GetAccountAddress

                                                func (appName AppType) GetAccountAddress(actname string) (GetAccountAddress, error)

                                                func (AppType) GetAddedNodeInfo

                                                func (appName AppType) GetAddedNodeInfo(params APIParams) (GetAddedNodeInfo, error)

                                                func (AppType) GetAddressesByAccount

                                                func (appName AppType) GetAddressesByAccount(actname string) (GetAddressesByAccount, error)

                                                func (AppType) GetBalance

                                                func (appName AppType) GetBalance(params APIParams) (GetBalance, error)

                                                func (AppType) GetBestBlockhash

                                                func (appName AppType) GetBestBlockhash() (GetBestBlockhash, error)

                                                  GetBestBlockhash method returns the hash of the best (tip) block in the longest block chain.

                                                  func (AppType) GetBlock

                                                  func (appName AppType) GetBlock(params APIParams) (GetBlock, error)

                                                    GetBlock method returns the block's relevant state information. The verbose input is optional. The default value is true, and it will return a json object with information about the indicated block. If verbose is false, the command returns a string that is serialized hex-encoded data for the indicated block.

                                                    func (AppType) GetBlockCount

                                                    func (appName AppType) GetBlockCount() (GetBlockCount, error)

                                                      GetBlockCount method returns the number of blocks in the best valid block chain.

                                                      func (AppType) GetBlockHash

                                                      func (appName AppType) GetBlockHash(h int) (GetBlockHash, error)

                                                        GetBlockHash method returns the hash of the indicated block index, according to the best blockchain at the time provided.

                                                        func (AppType) GetBlockHeader

                                                        func (appName AppType) GetBlockHeader(params APIParams) (GetBlockHeader, error)

                                                          GetBlockHeader method returns information about the indicated block. The verbose input is optional. If verbose is false, the method returns a string that is serialized, hex-encoded data for the indicated blockheader. If verbose is true, the method returns a json object with information about the indicated blockheader.

                                                          func (AppType) GetBlockSubsidy

                                                          func (appName AppType) GetBlockSubsidy(params APIParams) (GetBlockSubsidy, error)

                                                          func (AppType) GetBlockTemplate

                                                          func (appName AppType) GetBlockTemplate(params APIParams) (GetBlockTemplate, error)

                                                          func (AppType) GetBlockchainInfo

                                                          func (appName AppType) GetBlockchainInfo() (GetBlockchainInfo, error)

                                                            GetBlockchainInfo method returns a json object containing state information about blockchain processing.

                                                            func (AppType) GetChainTips

                                                            func (appName AppType) GetChainTips() (GetChainTips, error)

                                                              GetChainTips method returns information about all known tips in the block tree, including the main chain and any orphaned branches.

                                                              func (AppType) GetConnectionCount

                                                              func (appName AppType) GetConnectionCount() (GetConnectionCount, error)

                                                              func (AppType) GetCurrency

                                                              func (appName AppType) GetCurrency(params APIParams) (GetCurrency, error)

                                                                GetCurrency returns a complete definition for any given chain if it is registered on the blockchain. If the chain requested is NULL, chain definition of the current chain is returned.

                                                                getcurrency "chainname"

                                                                Arguments 1. "chainname" (string, optional) name of the chain to look for. no parameter returns current chain in daemon.

                                                                func (AppType) GetCurrencyConverters

                                                                func (appName AppType) GetCurrencyConverters(params APIParams) (GetCurrencyConverters, error)

                                                                  GetCurrencyConverters Retrieves all currencies that have at least 1000 VRSC in reserve, are >10% VRSC reserve ratio, and have all listed currencies as reserves

                                                                  getcurrencyconverters currency1 currency2 Arguments

                                                                  ["currencyname"    : "string", ...]  (string list, one or more) all selected currencies are returned with their current state
                                                                  

                                                                  Result:

                                                                  "[{currency1}, {currency2}]" : "array of objects" (string) All currencies and the last notarization, which are valid converters.
                                                                  

                                                                  Examples: > verus getcurrencyconverters currency1 currency2 ...

                                                                  func (AppType) GetCurrencyState

                                                                  func (appName AppType) GetCurrencyState(params APIParams) (GetCurrencyState, error)

                                                                    GetCurrencyState returns the total amount of preconversions that have been confirmed on the blockchain for the specified chain.

                                                                    getcurrencystate "n"

                                                                    Arguments

                                                                    "n" or "m,n" or "m,n,o"         (int or string, optional) height or inclusive range with optional step at which to get the currency state. If not specified, the latest currency state and height is returned
                                                                    

                                                                    func (AppType) GetDeprecationInfo

                                                                    func (appName AppType) GetDeprecationInfo() (GetDeprecationInfo, error)

                                                                    func (AppType) GetDifficulty

                                                                    func (appName AppType) GetDifficulty() (GetDifficulty, error)

                                                                      GetDifficulty method returns the proof-of-work difficulty as a multiple of the minimum difficulty.

                                                                      func (AppType) GetExports

                                                                      func (appName AppType) GetExports(params APIParams) (GetExports, error)

                                                                        GetExports returns all pending export transfers that are not yet provable with confirmed notarizations. These are the transactions that are crossing from one to another currency. In other words: conversions It's output behaves like a mempool transactions, and the output of results disappear after a while, and new ones shows up.

                                                                        getexports "chainname"

                                                                        Arguments 1. "chainname" (string, optional) name of the chain to look for. no parameter returns current chain in daemon.

                                                                        Example Result: [

                                                                        {
                                                                          "blockheight": 144,
                                                                          "exportid": "ea087427e81352bd84887ff90d370e8cf5c51b61f694c673b75b64696391d777",
                                                                          "description": {
                                                                            "version": 1,
                                                                            "exportcurrencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                            "numinputs": 2,
                                                                            "totalamounts": {
                                                                              "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3": 94.15731371,
                                                                              "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq": 1000250.06291562
                                                                            },
                                                                            "totalfees": {
                                                                              "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3": 0.02353932,
                                                                              "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq": 250.06291562
                                                                            }
                                                                          },
                                                                          "transfers": [
                                                                            {
                                                                              "version": 1,
                                                                              "currencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                              "value": 1000250.06251562,
                                                                              "flags": 4101,
                                                                              "preconvert": true,
                                                                              "fees": 0.0002,
                                                                              "destinationcurrencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                              "destination": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt"
                                                                            },
                                                                            {
                                                                              "version": 1,
                                                                              "currencyid": "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3",
                                                                              "value": 94.15731371,
                                                                              "flags": 4101,
                                                                              "preconvert": true,
                                                                              "fees": 0.0002,
                                                                              "destinationcurrencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                              "destination": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt"
                                                                            },
                                                                            {
                                                                              "version": 1,
                                                                              "currencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                              "value": 0,
                                                                              "flags": 9,
                                                                              "feeoutput": true,
                                                                              "fees": 0,
                                                                              "destinationcurrencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                              "destination": "RCdrw4BL7B8rKJ2iQqftvBA4SAtwGA3eBc"
                                                                            }
                                                                          ]
                                                                        },
                                                                        {},
                                                                        ...
                                                                        

                                                                        ]

                                                                        Examples: > verus getexports "chainname" > curl --user myusername --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getexports", "params": ["chainname"] }' -H 'content-type: text/plain;' http://127.0.0.1:27486/

                                                                        func (AppType) GetIdentity

                                                                        func (appName AppType) GetIdentity(params APIParams) (GetIdentity, error)

                                                                          GetIdentity searches blockchain and returns if there's matching VerusID found. getidentity "name"

                                                                          func (AppType) GetImports

                                                                          func (appName AppType) GetImports(params APIParams) (GetImports, error)

                                                                            GetImports returns all imports from a specific chain.

                                                                            getimports "chainname"

                                                                            Arguments 1. "chainname" (string, optional) name of the chain to look for. no parameter returns current chain in daemon.

                                                                            Example Result: [

                                                                            {
                                                                              "blockheight": 149,
                                                                              "importid": "c5b5aa070b57b6599ea8714692187f06261c215c641d13e06dacd74ed40272a3",
                                                                              "description": {
                                                                                "version": 1,
                                                                                "sourcesystemid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                                "importcurrencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                                "valuein": {
                                                                                  "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt": 1999933.86859995,
                                                                                  "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3": 94.15731371,
                                                                                  "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq": 1000500.06191861
                                                                                },
                                                                                "tokensout": {
                                                                                  "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3": 94.15731371
                                                                                }
                                                                              },
                                                                              "transfers": [
                                                                                {
                                                                                  "version": 1,
                                                                                  "currencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                                  "value": 1000250.06251562,
                                                                                  "flags": 4101,
                                                                                  "preconvert": true,
                                                                                  "fees": 0.0002,
                                                                                  "destinationcurrencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                                  "destination": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt"
                                                                                },
                                                                                {
                                                                                  "version": 1,
                                                                                  "currencyid": "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3",
                                                                                  "value": 94.15731371,
                                                                                  "flags": 4101,
                                                                                  "preconvert": true,
                                                                                  "fees": 0.0002,
                                                                                  "destinationcurrencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                                  "destination": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt"
                                                                                },
                                                                                {
                                                                                  "version": 1,
                                                                                  "currencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                                  "value": 0,
                                                                                  "flags": 9,
                                                                                  "feeoutput": true,
                                                                                  "fees": 0,
                                                                                  "destinationcurrencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                                  "destination": "RCdrw4BL7B8rKJ2iQqftvBA4SAtwGA3eBc"
                                                                                }
                                                                              ]
                                                                            },
                                                                            {},
                                                                            ...
                                                                            

                                                                            ]

                                                                            Examples: > verus getimports "chainname" > curl --user myusername --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getimports", "params": ["chainname"] }' -H 'content-type: text/plain;' http://127.0.0.1:27486/

                                                                            func (AppType) GetInfo

                                                                            func (appName AppType) GetInfo() (GetInfo, error)

                                                                              GetInfo gets some basic and essential information about local node's blockchain, wallet, and network specific info

                                                                              func (AppType) GetInitialCurrencyState

                                                                              func (appName AppType) GetInitialCurrencyState(params APIParams) (GetInitialCurrencyState, error)

                                                                                GetInitialCurrencyState returns the total amount of preconversions that have been confirmed on the blockchain for the specified PBaaS chain. This should be used to get information about chains that are not this chain, but are being launched by it.

                                                                                getinitialcurrencystate "name"

                                                                                Arguments

                                                                                "name"                    (string, required) name or chain ID of the chain to get the export transactions for
                                                                                

                                                                                Example Result: {

                                                                                "flags": 11,
                                                                                "currencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                                "reservecurrencies": [
                                                                                	{
                                                                                		"currencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                                		"weight": 0.50000000,
                                                                                		"reserves": 999750.00099701,
                                                                                		"priceinreserve": 0.99975000
                                                                                	},
                                                                                	{
                                                                                		"currencyid": "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3",
                                                                                		"weight": 0.50000000,
                                                                                		"reserves": 94.15731371,
                                                                                		"priceinreserve": 0.00009415
                                                                                	}
                                                                                ],
                                                                                "initialsupply": 2000000.00000000,
                                                                                "emitted": 0.00000000,
                                                                                "supply": 2000000.00000000,
                                                                                "currencies": {
                                                                                	"iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq": {
                                                                                		"reservein": 1000000.00000000,
                                                                                		"nativein": 0.00000000,
                                                                                		"reserveout": 249.99900299,
                                                                                		"lastconversionprice": 1.00000000,
                                                                                		"viaconversionprice": 0.99981249,
                                                                                		"fees": 250.06291562,
                                                                                		"conversionfees": 250.06251562
                                                                                	},
                                                                                	"iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3": {
                                                                                		"reservein": 94.15731371,
                                                                                		"nativein": 0.00000000,
                                                                                		"reserveout": 0.00000000,
                                                                                		"lastconversionprice": 0.00009414,
                                                                                		"viaconversionprice": 0.00009414,
                                                                                		"fees": 0.02353932,
                                                                                		"conversionfees": 0.02353932
                                                                                	}
                                                                                },
                                                                                "nativefees": 50006191861,
                                                                                "nativeconversionfees": 50006151861
                                                                                

                                                                                }

                                                                                Examples: > verus getinitialcurrencystate name > curl --user myusername --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getinitialcurrencystate", "params": [name] }' -H 'content-type: text/plain;' http://127.0.0.1:27486/

                                                                                func (AppType) GetLastImportin

                                                                                func (appName AppType) GetLastImportin(params APIParams) (GetLastImportin, error)

                                                                                  GetLastImportin returns the last import transaction from the chain specified and a blank transaction template to use when making new import transactions. Since the typical use for this call is to make new import transactions from the other chain that will be then broadcast to this chain, we include the template by default.

                                                                                  getlastimportin "fromname"

                                                                                  Arguments

                                                                                  "fromname"                (string, required) name of the chain to get the last import transaction in from
                                                                                  

                                                                                  Result:

                                                                                  {
                                                                                      "lastimporttransaction": "hex"      Hex encoded serialized import transaction
                                                                                      "lastconfirmednotarization" : "hex" Hex encoded last confirmed notarization transaction
                                                                                      "importtxtemplate": "hex"           Hex encoded import template for new import transactions
                                                                                      "nativeimportavailable": "amount"   Total amount of native import currency available to import as native
                                                                                      "tokenimportavailable": "array"     ([{"currencyid":amount},..], required) tokens available to import, if controlled by this chain
                                                                                  }
                                                                                  

                                                                                  Examples: > verus getlastimportin jsondefinition > curl --user myusername --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getlastimportin", "params": [jsondefinition] }' -H 'content-type: text/plain;' http://127.0.0.1:27486/

                                                                                  func (AppType) GetLocalSolps

                                                                                  func (appName AppType) GetLocalSolps() (GetLocalSolps, error)

                                                                                  func (AppType) GetMempoolInfo

                                                                                  func (appName AppType) GetMempoolInfo() (GetMempoolInfo, error)

                                                                                    GetMempoolInfo method returns details on the active state of the transaction memory pool.

                                                                                    func (AppType) GetMiningInfo

                                                                                    func (appName AppType) GetMiningInfo() (GetMiningInfo, error)

                                                                                    func (AppType) GetNetTotals

                                                                                    func (appName AppType) GetNetTotals() (GetNetTotals, error)

                                                                                    func (AppType) GetNetworkHashps

                                                                                    func (appName AppType) GetNetworkHashps(params APIParams) (GetNetworkHashps, error)

                                                                                    func (AppType) GetNetworkInfo

                                                                                    func (appName AppType) GetNetworkInfo() (GetNetworkInfo, error)

                                                                                    func (AppType) GetNetworkSolps

                                                                                    func (appName AppType) GetNetworkSolps(params APIParams) (GetNetworkSolps, error)

                                                                                    func (AppType) GetNewAddress

                                                                                    func (appName AppType) GetNewAddress() (GetNewAddress, error)

                                                                                    func (AppType) GetNotarizationData

                                                                                    func (appName AppType) GetNotarizationData(params APIParams) (GetNotarizationData, error)

                                                                                      GetNotarizationData returns the latest PBaaS notarization data for the specifed currencyid.

                                                                                      getnotarizationdata "currencyid" accepted

                                                                                      Arguments 1. "currencyid" (string, required) the hex-encoded ID or string name search for notarizations on 2. "accepted" (bool, optional) accepted, not earned notarizations, default: true if on

                                                                                      VRSC or VRSCTEST, false otherwise
                                                                                      

                                                                                      Example Result: {

                                                                                      "version": 1,
                                                                                      "notarizations": [
                                                                                        {
                                                                                      	"index": 0,
                                                                                      	"txid": "936e0f4f318bf21c0cd804037526e336f8162bdf2409f72134868119752efd8f",
                                                                                      	"notarization": {
                                                                                      	  "version": 1,
                                                                                      	  "currencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                                      	  "notaryaddress": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                                      	  "notarizationheight": 31112,
                                                                                      	  "mmrroot": "9f95c86ffc6d7f076370dcb27c198c18505281e1abbf4bac742e46a005597548",
                                                                                      	  "notarizationprehash": "4cbe080e1d9c188ab1bd56f4915298b6671aa556be1161ed8b0bebb5085bc5d6",
                                                                                      	  "work": "00000000000000000000000000000000000000000000000000000000195f61be",
                                                                                      	  "stake": "0000000000000000000000000000000000000000000000000000000000000000",
                                                                                      	  "currencystate": {
                                                                                      		"flags": 3,
                                                                                      		"currencyid": "i84mndBk2Znydpgm9T9pTjVvBnHkhErzLt",
                                                                                      		"reservecurrencies": [
                                                                                      		  {
                                                                                      			"currencyid": "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq",
                                                                                      			"weight": 0.50000000,
                                                                                      			"reserves": 999894.45679682,
                                                                                      			"priceinreserve": 0.99983971
                                                                                      		  },
                                                                                      		  {
                                                                                      			"currencyid": "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3",
                                                                                      			"weight": 0.50000000,
                                                                                      			"reserves": 94.15401986,
                                                                                      			"priceinreserve": 0.00009414
                                                                                      		  }
                                                                                      		],
                                                                                      		"initialsupply": 2000000.00000000,
                                                                                      		"emitted": 0.00000000,
                                                                                      		"supply": 2000109.49758289,
                                                                                      		"currencies": {
                                                                                      		  "iJhCezBExJHvtyH3fGhNnt2NhU4Ztkf2yq": {
                                                                                      			"reservein": 0.00000000,
                                                                                      			"nativein": 0.99923512,
                                                                                      			"reserveout": 0.99907519,
                                                                                      			"lastconversionprice": 0.99983995,
                                                                                      			"viaconversionprice": 0.99982722,
                                                                                      			"fees": 0.00000000,
                                                                                      			"conversionfees": 0.00000000
                                                                                      		  },
                                                                                      		  "iBBRjDbPf3wdFpghLotJQ3ESjtPBxn6NS3": {
                                                                                      			"reservein": 0.00000000,
                                                                                      			"nativein": 0.00000000,
                                                                                      			"reserveout": 0.00000000,
                                                                                      			"lastconversionprice": 0.00009414,
                                                                                      			"viaconversionprice": 0.00009414,
                                                                                      			"fees": 0.00000000,
                                                                                      			"conversionfees": 0.00000000
                                                                                      		  }
                                                                                      		},
                                                                                      		"nativefees": 12490,
                                                                                      		"nativeconversionfees": 0
                                                                                      	  },
                                                                                      	  "prevnotarization": "a694a22cc3aee0212105021f5363803f87ff2fc49689749d3feb563fd1c9c2ab",
                                                                                      	  "prevheight": 31081,
                                                                                      	  "crossnotarization": "0000000000000000000000000000000000000000000000000000000000000000",
                                                                                      	  "crossheight": 0,
                                                                                      	  "nodes": [
                                                                                      	  ]
                                                                                      	}
                                                                                        }
                                                                                      ],
                                                                                      "forks": [
                                                                                        [
                                                                                      	0
                                                                                        ]
                                                                                      ],
                                                                                      "lastconfirmedheight": 31112,
                                                                                      "lastconfirmed": 0,
                                                                                      "bestchain": 0
                                                                                      

                                                                                      }

                                                                                      Examples: > verus getnotarizationdata "currencyid" true > curl --user myusername --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getnotarizationdata", "params": ["currencyid"] }' -H 'content-type: text/plain;' http://127.0.0.1:27486/

                                                                                      func (AppType) GetPeerInfo

                                                                                      func (appName AppType) GetPeerInfo() (GetPeerInfo, error)

                                                                                      func (AppType) GetRawChangeAddress

                                                                                      func (appName AppType) GetRawChangeAddress() (GetRawChangeAddress, error)

                                                                                      func (AppType) GetRawMempoolFalse

                                                                                      func (appName AppType) GetRawMempoolFalse(b bool) (GetRawMempoolFalse, error)

                                                                                        GetRawMempoolFalse method returns all transaction ids in the memory pool as a json array of transaction ids. The verbose input is optional and is false by default. When it is true, the method instead returns a json object with various related data.

                                                                                        func (AppType) GetRawMempoolTrue

                                                                                        func (appName AppType) GetRawMempoolTrue(b bool) (GetRawMempoolTrue, error)

                                                                                          GetRawMempoolTrue method returns all transaction ids in the memory pool as a json array of transaction ids. The verbose input is optional and is false by default. When it is true, the method instead returns a json object with various related data.

                                                                                          func (AppType) GetRawTransaction

                                                                                          func (appName AppType) GetRawTransaction(params APIParams) (GetRawTransaction, error)

                                                                                          func (AppType) GetRawTransactionDetailed

                                                                                          func (appName AppType) GetRawTransactionDetailed(params APIParams) (GetRawTransactionDetailed, error)

                                                                                          func (AppType) GetReceivedByAccount

                                                                                          func (appName AppType) GetReceivedByAccount(params APIParams) (GetReceivedByAccount, error)

                                                                                          func (AppType) GetReceivedByAddress

                                                                                          func (appName AppType) GetReceivedByAddress(params APIParams) (GetReceivedByAddress, error)

                                                                                          func (AppType) GetTransaction

                                                                                          func (appName AppType) GetTransaction(params APIParams) (GetTransaction, error)

                                                                                          func (AppType) GetTxOut

                                                                                          func (appName AppType) GetTxOut(params APIParams) (GetTxOut, error)

                                                                                            GetTxOut method returns details about an unspent transaction output.

                                                                                            func (AppType) GetTxOutProof

                                                                                            func (appName AppType) GetTxOutProof(txids string) (GetTxOutProof, error)

                                                                                              GetTxOutProof method returns a hex-encoded proof showing that the indicated transaction was included in a block.

                                                                                              func (AppType) GetTxOutSetInfo

                                                                                              func (appName AppType) GetTxOutSetInfo() (GetTxOutSetInfo, error)

                                                                                                GetTxOutSetInfo method returns statistics about the unspent transaction output set.

                                                                                                func (AppType) GetUnconfirmedBalance

                                                                                                func (appName AppType) GetUnconfirmedBalance() (GetUnconfirmedBalance, error)

                                                                                                func (AppType) GetWalletInfo

                                                                                                func (appName AppType) GetWalletInfo() (GetWalletInfo, error)

                                                                                                func (AppType) ImportAddress

                                                                                                func (appName AppType) ImportAddress(params APIParams) (ImportAddress, error)

                                                                                                func (AppType) ImportPrivKey

                                                                                                func (appName AppType) ImportPrivKey(params APIParams) (ImportPrivKey, error)

                                                                                                func (AppType) ImportWallet

                                                                                                func (appName AppType) ImportWallet(wltpth string) (ImportWallet, error)

                                                                                                func (AppType) KeyPoolRefill

                                                                                                func (appName AppType) KeyPoolRefill(params APIParams) (KeyPoolRefill, error)

                                                                                                func (AppType) ListAccounts

                                                                                                func (appName AppType) ListAccounts(params APIParams) (ListAccounts, error)

                                                                                                func (AppType) ListAddressGroupings

                                                                                                func (appName AppType) ListAddressGroupings() (ListAddressGroupings, error)

                                                                                                func (AppType) ListBanned

                                                                                                func (appName AppType) ListBanned() (ListBanned, error)

                                                                                                func (AppType) ListCurrencies

                                                                                                func (appName AppType) ListCurrencies(params APIParams) (ListCurrencies, error)

                                                                                                  ListCurrencies returns a complete definition for any given chain if it is registered on the blockchain. If the chain requested is NULL, chain definition of the current chain is returned.

                                                                                                  listcurrencies (includeexpired)

                                                                                                  Arguments 1. "includeexpired" (bool, optional) if true, include chains that are no longer active

                                                                                                  Result: [

                                                                                                  {
                                                                                                    "version" : n,                 (int) version of this chain definition
                                                                                                    "name" : "string",           (string) name or symbol of the chain, same as passed
                                                                                                    "address" : "string",        (string) cryptocurrency address to send fee and non-converted premine
                                                                                                    "currencyid" : "hex-string", (string) i-address that represents the chain ID, same as the ID that launched the chain
                                                                                                    "premine" : n,                 (int) amount of currency paid out to the premine address in block #1, may be smart distribution
                                                                                                    "convertible" : "xxxx"       (bool) if this currency is a fractional reserve currency of Verus
                                                                                                    "startblock" : n,              (int) block # on this chain, which must be notarized into block one of the chain
                                                                                                    "endblock" : n,                (int) block # after which, this chain's useful life is considered to be over
                                                                                                    "eras" : "[obj, ...]",       (objarray) different chain phases of rewards and convertibility
                                                                                                    {
                                                                                                      "reward" : "[n, ...]",     (int) reward start for each era in native coin
                                                                                                      "decay" : "[n, ...]",      (int) exponential or linear decay of rewards during each era
                                                                                                      "halving" : "[n, ...]",    (int) blocks between halvings during each era
                                                                                                      "eraend" : "[n, ...]",     (int) block marking the end of each era
                                                                                                      "eraoptions" : "[n, ...]", (int) options (reserved)
                                                                                                    }
                                                                                                    "nodes"      : "[obj, ..]",  (objectarray, optional) up to 2 nodes that can be used to connect to the blockchain      [{
                                                                                                         "nodeaddress" : "txid", (string,  optional) internet, TOR, or other supported address for node
                                                                                                         "paymentaddress" : n,     (int,     optional) rewards payment address
                                                                                                       }, .. ]
                                                                                                  }, ...
                                                                                                  

                                                                                                  ]

                                                                                                  Examples: > verus listcurrencies true > curl --user myusername --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "listcurrencies", "params": [true] }' -H 'content-type: text/plain;' http://127.0.0.1:27486/

                                                                                                  func (AppType) ListIdentities

                                                                                                  func (appName AppType) ListIdentities(params APIParams) (ListIdentities, error)

                                                                                                    ListIdentities lists identities available in your wallet

                                                                                                    listidentities (includecansign) (includewatchonly)

                                                                                                    Arguments "includecanspend" (bool, optional, default=true) Include identities for which we can spend/authorize "includecansign" (bool, optional, default=true) Include identities that we can only sign for but not spend "includewatchonly" (bool, optional, default=false) Include identities that we can neither sign nor spend, but are either watched or are co-signers with us

                                                                                                    func (AppType) ListLockUnspent

                                                                                                    func (appName AppType) ListLockUnspent() (ListLockUnspent, error)

                                                                                                    func (AppType) ListReceivedByAddress

                                                                                                    func (appName AppType) ListReceivedByAddress(params APIParams) (ListReceivedByAddress, error)

                                                                                                    func (AppType) ListSinceBlock

                                                                                                    func (appName AppType) ListSinceBlock(params APIParams) (ListSinceBlock, error)

                                                                                                    func (AppType) ListTransactions

                                                                                                    func (appName AppType) ListTransactions(params APIParams) (ListTransactions, error)

                                                                                                    func (AppType) ListUnspent

                                                                                                    func (appName AppType) ListUnspent(params APIParams) (ListUnspent, error)

                                                                                                    func (AppType) LockUnspent

                                                                                                    func (appName AppType) LockUnspent(params APIParams) (LockUnspent, error)

                                                                                                    func (AppType) MinerIDs

                                                                                                    func (appName AppType) MinerIDs(ht string) (MinerIDs, error)

                                                                                                      MinerIDs method returns information about the notary nodes and external miners at a specific block height. The response will calculate results according to the 2000 blocks proceeding the indicated "height" block.

                                                                                                      func (AppType) Notaries

                                                                                                      func (appName AppType) Notaries(ht string) (Notaries, error)

                                                                                                        Notaries method returns the public key, BTC address, and KMD address for each Komodo notary node. Either or both of the height and timestamp parameters will suffice

                                                                                                        func (AppType) Ping

                                                                                                        func (appName AppType) Ping() (Ping, error)

                                                                                                        func (AppType) PrioritiseTransaction

                                                                                                        func (appName AppType) PrioritiseTransaction(params APIParams) (PrioritiseTransaction, error)

                                                                                                        func (AppType) RGBailout

                                                                                                        func (appName AppType) RGBailout(params APIParams) (RGBailout, error)

                                                                                                          RGBailout ...

                                                                                                          func (AppType) RGGameInfo

                                                                                                          func (appName AppType) RGGameInfo(params APIParams) (RGGameInfo, error)

                                                                                                            RGGameInfo ...

                                                                                                            func (AppType) RGGames

                                                                                                            func (appName AppType) RGGames() (RGGames, error)

                                                                                                              RGGames ...

                                                                                                              func (AppType) RGHighLander

                                                                                                              func (appName AppType) RGHighLander(params APIParams) (RGHighLander, error)

                                                                                                                RGHighLander ...

                                                                                                                func (AppType) RGNewGame

                                                                                                                func (appName AppType) RGNewGame(params APIParams) (RGNewGame, error)

                                                                                                                RGNewGame - Crypto-Conditions (CC) specific method. You can see all available methods via cclib with following command Method: newgame Params: maxplayers buyin Params Required: 0 Max Parameters 2

                                                                                                                Example command

                                                                                                                ./komodo-cli -ac_name=ROGUE cclib newgame 17 \"[3,10]\"
                                                                                                                

                                                                                                                Explanation

                                                                                                                cclib: API call method.

                                                                                                                ./komodo-cli -ac_name=ROGUE cclibinfo
                                                                                                                

                                                                                                                17: Evalcode for this CC method

                                                                                                                Array value 3: value of `maxplayers`. The maximum players that can participate in this game.

                                                                                                                Array value 10: value of `buyin`. Each new player participating in this game need to put 10 ROGUE coins to participate.

                                                                                                                The winner will be the player who will be last standing, i.e. not killed, while others are killed.

                                                                                                                And this winner takes all the buyin total of 3 players, which is equals to 30 ROGUE, also the GOLD converted to ROGUE from all these players.

                                                                                                                func (AppType) RGPending

                                                                                                                func (appName AppType) RGPending() (RGPending, error)

                                                                                                                  RGPending ...

                                                                                                                  func (AppType) RGPlayerInfo

                                                                                                                  func (appName AppType) RGPlayerInfo(params APIParams) (RGPlayerInfo, error)

                                                                                                                    RGPlayerInfo ...

                                                                                                                    func (AppType) RGPlayers

                                                                                                                    func (appName AppType) RGPlayers() (RGPlayers, error)

                                                                                                                      RGPlayers ...

                                                                                                                      func (AppType) RGRegister

                                                                                                                      func (appName AppType) RGRegister(params APIParams) (RGRegister, error)

                                                                                                                        RGRegister ...

                                                                                                                        func (AppType) RGSetName

                                                                                                                        func (appName AppType) RGSetName(params APIParams) (RGSetName, error)

                                                                                                                          RGSetName ...

                                                                                                                          func (AppType) RPCResultMap

                                                                                                                          func (appName AppType) RPCResultMap(method string, params interface{}) (interface{}, error)

                                                                                                                            RPCResultMap using golang's own http package

                                                                                                                            func (AppType) RegisterIdentity

                                                                                                                            func (appName AppType) RegisterIdentity(params APIParams) (RegisterIdentity, error)

                                                                                                                              RegisterIdentity gets the values from RegisterNameCommitment output and uses those to register VerusID

                                                                                                                              registeridentity "jsonidregistration" feeoffer

                                                                                                                              Arguments {

                                                                                                                              	"txid": "hexid",			(hex)    the transaction ID of the name committment for this ID name - Taken from RegisterNameCommitment's output - txid
                                                                                                                              	"namereservation": {
                                                                                                                              	  "name": "namestr",		(string) the unique name in this commitment - Taken from RegisterNameCommitment's output - name
                                                                                                                              	  "salt": "hexstr",			(hex)    salt used to hide the commitment - Taken from RegisterNameCommitment's output - salt
                                                                                                                              	  "referral": "identityID",	(name@ or address) must be a valid ID to use as a referrer to receive a discount - Taken from RegisterNameCommitment's output - referral
                                                                                                                              	  "parent": "",				(name@ or address) must be a valid ID. This ID can be used to revoke and recover the nameID we regsiter with this current command - Taken from RegisterNameCommitment's output - parent
                                                                                                                              	  "nameid": "nameID"		(base58) identity address for this identity if it is created - Taken from RegisterNameCommitment's output - nameid
                                                                                                                              	},
                                                                                                                              	"identity": {
                                                                                                                              	  "name": "namestr",		(string) the unique name for this identity - Taken from RegisterNameCommitment's output - name
                                                                                                                              	  "primaryaddresses": [		(array of strings) the trasparent/public address(es)
                                                                                                                              		"hexstr"
                                                                                                                              	  ],
                                                                                                                              	  "minimumsignatures": 1,	(int) MofN signatures required out of the primary addresses list to sign transactions
                                                                                                                                 "revocationauthority": "namestr", (name@ or address) The ID entered here will be able to disable your created ID in case of loss or theft. It is some existing ID which either is under your own control or the ID you trust can help you revoke in case of this ID's theft.
                                                                                                                                 "recoveryauthority": "namestr",	(name@ or address) The ID entered here will be able to revive your created ID if it is revoked. It is some existing ID which either is under your own control or the ID you trust can help you revive in case of this ID's revoked.
                                                                                                                              	  "privateaddress": "hexstr"	(string) shielded address associated with the VerusID being made
                                                                                                                              	}
                                                                                                                              

                                                                                                                              } feeoffer (amount, optional) amount to offer miner/staker for the registration fee, if missing, uses standard price

                                                                                                                              func (AppType) RegisterNameCommitment

                                                                                                                              func (appName AppType) RegisterNameCommitment(params APIParams) (RegisterNameCommitment, error)

                                                                                                                                RegisterNameCommitment - Registers a name commitment, which is required as a source for the name to be used when registering an identity. The name commitment hides the name itself while ensuring that the miner who mines in the registration cannot front-run the name unless they have also registered a name commitment for the same name or are willing to forfeit the offer of payment for the chance that a commitment made now will allow them to register the name in the future.

                                                                                                                                NOTE: Invalid name for commitment. Names must not have leading or trailing spaces and must not include any of the following characters between parentheses (\/:*?"<>|@)

                                                                                                                                registernamecommitment "name" "controladdress" ("referralidentity")

                                                                                                                                Arguments "name" (string, required) the unique name to commit to. creating a name commitment is not a registration, and if one is created for a name that exists, it may succeed, but will never be able to be used. "controladdress" (address, required) address that will control this commitment "referralidentity" (identity, optional)friendly name or identity address that is provided as a referral mechanism and to lower network cost of the ID

                                                                                                                                func (AppType) SendCurrency

                                                                                                                                func (appName AppType) SendCurrency(params APIParams) (SendCurrency, error)

                                                                                                                                  SendCurrency sends one or many Verus outputs to one or many addresses on the same or another chain. Funds are sourced automatically from the current wallet, which must be present, as in sendtoaddress. If "fromaddress" is specified, all funds will be taken from that address, otherwise funds may come from any source set of UTXOs controlled by the wallet.

                                                                                                                                  sendcurrency "fromaddress" '[{"address":... ,"amount":...},...]' (returntx)

                                                                                                                                  Arguments 1. "fromaddress" (string, required) The VerusID or address to send the funds from. "*" means all addresses 2. "outputs" (array, required) An array of json objects representing currencies, amounts, and destinations to send.

                                                                                                                                  [{
                                                                                                                                    "currency": "name"   (string, required) Name of the source currency to send in this output, defaults to native of chain
                                                                                                                                    "amount":amount        (numeric, required) The numeric amount of currency, denominated in source currency
                                                                                                                                    "convertto":"name",  (string, optional) Valid currency to convert to, either a reserve of a fractional, or fractional
                                                                                                                                    "via":"name",        (string, optional) If source and destination currency are reserves, via is a common fractional to convert through
                                                                                                                                    "address":"dest"     (string, required) The address and optionally chain/system after the "@" as a system specific destination
                                                                                                                                    "refundto":"dest"    (string, optional) For pre-conversions, this is where refunds will go, defaults to fromaddress
                                                                                                                                    "memo":memo            (string, optional) If destination is a zaddr (not supported on testnet), a string message (not hexadecimal) to include.
                                                                                                                                    "preconvert":"false", (bool,   optional) auto-convert to PBaaS currency at market price, this only works if the order is mined before block start of the chain
                                                                                                                                    "subtractfee":"bool", (bool,   optional) if true, output must be of native or convertible reserve currency, and output will be reduced by share of fee
                                                                                                                                  }, ... ]
                                                                                                                                  

                                                                                                                                  3. "returntx" (bool, optional) defaults to false and transaction is sent, if true, transaction is signed and returned

                                                                                                                                  Result:

                                                                                                                                  "txid" : "transactionid" (string) The transaction id if (returntx) is false
                                                                                                                                  "hextx" : "hex"         (string) The hexadecimal, serialized transaction if (returntx) is true
                                                                                                                                  

                                                                                                                                  Examples: > verus sendcurrency "*" '[{"currency":"btc","address":"RRehdmUV7oEAqoZnzEGBH34XysnWaBatct" ,"amount":500.0},...]' > curl --user myusername --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "sendcurrency", "params": ["bob@" '[{"currency":"btc", "address":"alice@quad", "amount":500.0},...]'] }' -H 'content-type: text/plain;' http://127.0.0.1:27486/

                                                                                                                                  func (AppType) SendFrom

                                                                                                                                  func (appName AppType) SendFrom(params APIParams) (SendFrom, error)

                                                                                                                                  func (AppType) SendMany

                                                                                                                                  func (appName AppType) SendMany(params APIParams) (SendMany, error)

                                                                                                                                  func (AppType) SendRawTransaction

                                                                                                                                  func (appName AppType) SendRawTransaction(params APIParams) (SendRawTransaction, error)

                                                                                                                                  func (AppType) SendToAddress

                                                                                                                                  func (appName AppType) SendToAddress(params APIParams) (SendToAddress, error)

                                                                                                                                  func (AppType) SetBan

                                                                                                                                  func (appName AppType) SetBan(params APIParams) (SetBan, error)

                                                                                                                                  func (AppType) SetPubKey

                                                                                                                                  func (appName AppType) SetPubKey(pubkey string) (SetPubKey, error)

                                                                                                                                  func (AppType) SetTxFee

                                                                                                                                  func (appName AppType) SetTxFee(amount float64) (SetTxFee, error)

                                                                                                                                  func (AppType) SignMessage

                                                                                                                                  func (appName AppType) SignMessage(params APIParams) (SignMessage, error)

                                                                                                                                  func (AppType) SignRawTransaction

                                                                                                                                  func (appName AppType) SignRawTransaction(params APIParams) (SignRawTransaction, error)

                                                                                                                                  func (AppType) Stop

                                                                                                                                  func (appName AppType) Stop() (Stop, error)

                                                                                                                                    Stop method allows to issue a blockchain daemon service shutdown command

                                                                                                                                    func (AppType) SubmitBlock

                                                                                                                                    func (appName AppType) SubmitBlock(params APIParams) (SubmitBlock, error)

                                                                                                                                    func (AppType) UpdateIdentity

                                                                                                                                    func (appName AppType) UpdateIdentity(params APIParams) (UpdateIdentity, error)

                                                                                                                                      UpdateIdentity gets the values from GetIdentity output and uses those to update VerusID

                                                                                                                                      updateidentity "jsonidregistration" (returntx)

                                                                                                                                      Arguments {

                                                                                                                                      "parent": "address",		(name@ or address) must be a valid ID. This ID can be used to revoke and recover the nameID we regsiter with this current command - Taken from GetIdentity's output - parent
                                                                                                                                      "name": "namestr",			(string) the unique name in this commitment - Taken from GetIdentity's output - name
                                                                                                                                      "flags": number,			(int) default value is 0.
                                                                                                                                      "timelock": 1219040,		(int) block height to define.
                                                                                                                                      "primaryaddresses": [		(array of strings) the trasparent/public address(es)
                                                                                                                                      	"hexstr"
                                                                                                                                      ],
                                                                                                                                      "minimumsignatures": 1,		(int) MofN signatures required out of the primary addresses list to sign transactions
                                                                                                                                      "contentmap": {},			(string) it takes a 20 byte key and 32 byte value, expected to be a key hash and whatever other hash for value you want for content addressable storage. It needs to be a 20 byte (40 char)hex value key and a 32 byte (64) hex value value. It is an object of key/values.
                                                                                                                                      "revocationauthority": "namestr",	(name@ or address) The ID entered here will be able to disable your created ID in case of loss or theft. It is some existing ID which either is under your own control or the ID you trust can help you revoke in case of this ID's theft.
                                                                                                                                      "recoveryauthority": "namestr",		(name@ or address) The ID entered here will be able to revive your created ID if it is revoked. It is some existing ID which either is under your own control or the ID you trust can help you revive in case of this ID's revoked.
                                                                                                                                      "privateaddress": "hexstr"			(string) shielded address associated with the VerusID being made
                                                                                                                                      

                                                                                                                                      } "returntx" (bool, optional) defaults to false and transaction is sent, if true, transaction is signed by this wallet and returned

                                                                                                                                      ## Command Examples Time Lock: The timelock parameter defines the unlock height of the identity.

                                                                                                                                      verus -chain=VRSCTEST updateidentity '{"name": "ID@", "flags": 0, "timelock": <Unlock block height>, "minimumsignatures": 1, "primaryaddresses": ["t-address"]}'
                                                                                                                                      

                                                                                                                                      Time Delay: The timelock parameter defines how many blocks to delay an ID's unlock when the flags are set back to an unlocked state.

                                                                                                                                      verus -chain=VRSCTEST updateidentity '{"name": "ID@", "flags": 2, "timelock": <Unlock block delay>, "minimumsignatures": 1, "primaryaddresses": ["t-address"]}'
                                                                                                                                      

                                                                                                                                      func (AppType) ValidateAddress

                                                                                                                                      func (appName AppType) ValidateAddress(taddr string) (ValidateAddress, error)

                                                                                                                                        ValidateAddress method allows to check the information about a single wallet address's status

                                                                                                                                        func (AppType) VerifyChain

                                                                                                                                        func (appName AppType) VerifyChain(params APIParams) (VerifyChain, error)

                                                                                                                                          VerifyChain method verifies the coin daemon's blockchain database.

                                                                                                                                          func (AppType) VerifyMessage

                                                                                                                                          func (appName AppType) VerifyMessage(params APIParams) (VerifyMessage, error)

                                                                                                                                            VerifyMessage - Verify a signed message

                                                                                                                                            verifymessage "address or identity" "signature" "message" "checklatest"

                                                                                                                                            Arguments: 1. "t-addr or identity" (string, required) The transparent address or identity that signed the message. 2. "signature" (string, required) The signature provided by the signer in base 64 encoding (see signmessage). 3. "message" (string, required) The message that was signed. 3. "checklatest" (bool, optional) If true, checks signature validity based on latest identity. defaults to false,

                                                                                                                                            which determines validity of signing height stored in signature.
                                                                                                                                            

                                                                                                                                            Result: true|false (boolean) If the signature is verified or not.

                                                                                                                                            func (AppType) VerifyTxOutProof

                                                                                                                                            func (appName AppType) VerifyTxOutProof(pf string) (VerifyTxOutProof, error)

                                                                                                                                              VerifyTxOutProof method verifies that a proof points to a transaction in a block. It returns the transaction to which the proof is committed, or it will throw an RPC error if the block is not in the current best chain

                                                                                                                                              func (AppType) WalletLock

                                                                                                                                              func (appName AppType) WalletLock() (WalletLock, error)

                                                                                                                                              func (AppType) WalletPassPhrase

                                                                                                                                              func (appName AppType) WalletPassPhrase(params APIParams) (WalletPassPhrase, error)

                                                                                                                                              func (AppType) WalletPassPhrasechangeChange

                                                                                                                                              func (appName AppType) WalletPassPhrasechangeChange(params APIParams) (WalletPassPhrasechangeChange, error)

                                                                                                                                              func (AppType) ZExportKey

                                                                                                                                              func (appName AppType) ZExportKey(zaddr string) (ZExportKey, error)

                                                                                                                                              func (AppType) ZExportViewingKey

                                                                                                                                              func (appName AppType) ZExportViewingKey(zaddr string) (ZExportViewingKey, error)

                                                                                                                                              func (AppType) ZExportWallet

                                                                                                                                              func (appName AppType) ZExportWallet(wltfile string) (ZExportWallet, error)

                                                                                                                                              func (AppType) ZGetBalance

                                                                                                                                              func (appName AppType) ZGetBalance(params APIParams) (ZGetBalance, error)

                                                                                                                                              func (AppType) ZGetNewAddress

                                                                                                                                              func (appName AppType) ZGetNewAddress(tp string) (ZGetNewAddress, error)

                                                                                                                                              func (AppType) ZGetOperationResult

                                                                                                                                              func (appName AppType) ZGetOperationResult(params APIParams) (ZGetOperationResult, error)

                                                                                                                                              func (AppType) ZGetOperationStatus

                                                                                                                                              func (appName AppType) ZGetOperationStatus(params APIParams) (ZGetOperationStatus, error)

                                                                                                                                              func (AppType) ZGetTotalBalance

                                                                                                                                              func (appName AppType) ZGetTotalBalance(params APIParams) (ZGetTotalBalance, error)

                                                                                                                                              func (AppType) ZImportKey

                                                                                                                                              func (appName AppType) ZImportKey(params APIParams) (ZImportKey, error)

                                                                                                                                              func (AppType) ZImportViewingKey

                                                                                                                                              func (appName AppType) ZImportViewingKey(params APIParams) (ZImportViewingKey, error)

                                                                                                                                              func (AppType) ZImportWallet

                                                                                                                                              func (appName AppType) ZImportWallet(wltfile string) (ZImportWallet, error)

                                                                                                                                              func (AppType) ZListAddresses

                                                                                                                                              func (appName AppType) ZListAddresses(params APIParams) (ZListAddresses, error)

                                                                                                                                              func (AppType) ZListOperationIDs

                                                                                                                                              func (appName AppType) ZListOperationIDs(params APIParams) (ZListOperationIDs, error)

                                                                                                                                              func (AppType) ZListReceivedByAddress

                                                                                                                                              func (appName AppType) ZListReceivedByAddress(params APIParams) (ZListReceivedByAddress, error)

                                                                                                                                              func (AppType) ZListUnspent

                                                                                                                                              func (appName AppType) ZListUnspent(params APIParams) (ZListUnspent, error)

                                                                                                                                              func (AppType) ZMergeToAddress

                                                                                                                                              func (appName AppType) ZMergeToAddress(params APIParams) (ZMergeToAddress, error)

                                                                                                                                              func (AppType) ZSendMany

                                                                                                                                              func (appName AppType) ZSendMany(params APIParams) (ZSendMany, error)

                                                                                                                                              func (AppType) ZShieldCoinbase

                                                                                                                                              func (appName AppType) ZShieldCoinbase(params APIParams) (ZShieldCoinbase, error)

                                                                                                                                              func (AppType) ZValidateAddress

                                                                                                                                              func (appName AppType) ZValidateAddress(zaddr string) (ZValidateAddress, error)

                                                                                                                                                ZValidateAddress returns information about the given z address.

                                                                                                                                                z_validateaddress "zaddr"

                                                                                                                                                Arguments: 1. "zaddr" (string, required) The z address to validate

                                                                                                                                                Result: {

                                                                                                                                                "isvalid" : true|false,      (boolean) If the address is valid or not. If not, this is the only property returned.
                                                                                                                                                "address" : "zaddr",         (string) The z address validated
                                                                                                                                                "type" : "xxxx",             (string) "sprout" or "sapling"
                                                                                                                                                "ismine" : true|false,       (boolean) If the address is yours or not
                                                                                                                                                "payingkey" : "hex",         (string) [sprout] The hex value of the paying key, a_pk
                                                                                                                                                "transmissionkey" : "hex",   (string) [sprout] The hex value of the transmission key, pk_enc
                                                                                                                                                "diversifier" : "hex",       (string) [sapling] The hex value of the diversifier, d
                                                                                                                                                "diversifiedtransmissionkey" : "hex", (string) [sapling] The hex value of pk_d
                                                                                                                                                

                                                                                                                                                }

                                                                                                                                                type BackupWallet

                                                                                                                                                type BackupWallet struct {
                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                }

                                                                                                                                                type CCLibAddress

                                                                                                                                                type CCLibAddress struct {
                                                                                                                                                	Result struct {
                                                                                                                                                		Result               string  `json:"result"`
                                                                                                                                                		CClibCCAddress       string  `json:"CClibCCAddress"`
                                                                                                                                                		CCbalance            float64 `json:"CCbalance"`
                                                                                                                                                		CClibNormalAddress   string  `json:"CClibNormalAddress"`
                                                                                                                                                		CClibCCTokensAddress string  `json:"CClibCCTokensAddress"`
                                                                                                                                                		MyAddress            string  `json:"myAddress"`
                                                                                                                                                		MyCCAddressCClib     string  `json:"myCCAddress(CClib)"`
                                                                                                                                                		MyCCaddress          string  `json:"myCCaddress"`
                                                                                                                                                		MyCCbalance          float64 `json:"myCCbalance"`
                                                                                                                                                		Myaddress            string  `json:"myaddress"`
                                                                                                                                                		Mybalance            float64 `json:"mybalance"`
                                                                                                                                                	} `json:"result"`
                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                }

                                                                                                                                                  CCLibAddress type

                                                                                                                                                  type CCLibInfo

                                                                                                                                                  type CCLibInfo struct {
                                                                                                                                                  	Result struct {
                                                                                                                                                  		Result  string `json:"result"`
                                                                                                                                                  		CClib   string `json:"CClib"`
                                                                                                                                                  		Methods []struct {
                                                                                                                                                  			Evalcode       int    `json:"evalcode"`
                                                                                                                                                  			Funcid         string `json:"funcid"`
                                                                                                                                                  			Name           string `json:"name"`
                                                                                                                                                  			Method         string `json:"method"`
                                                                                                                                                  			Help           string `json:"help"`
                                                                                                                                                  			ParamsRequired int    `json:"params_required"`
                                                                                                                                                  			ParamsMax      int    `json:"params_max"`
                                                                                                                                                  		} `json:"methods"`
                                                                                                                                                  	} `json:"result"`
                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                  }

                                                                                                                                                    CCLibInfo type

                                                                                                                                                    type ClearBanned

                                                                                                                                                    type ClearBanned struct {
                                                                                                                                                    	Result string `json:"result"`
                                                                                                                                                    	Error  Error  `json:"error"`
                                                                                                                                                    	ID     string `json:"id"`
                                                                                                                                                    }

                                                                                                                                                    type CoinSupply

                                                                                                                                                    type CoinSupply struct {
                                                                                                                                                    	Result struct {
                                                                                                                                                    		Result string  `json:"result"`
                                                                                                                                                    		Coin   string  `json:"coin"`
                                                                                                                                                    		Height int     `json:"height"`
                                                                                                                                                    		Supply float64 `json:"supply"`
                                                                                                                                                    		Zfunds float64 `json:"zfunds"`
                                                                                                                                                    		Sprout float64 `json:"sprout"`
                                                                                                                                                    		Total  float64 `json:"total"`
                                                                                                                                                    	} `json:"result"`
                                                                                                                                                    	Error Error  `json:"error"`
                                                                                                                                                    	ID    string `json:"id"`
                                                                                                                                                    }

                                                                                                                                                      CoinSupply type

                                                                                                                                                      type CreateRawTransaction

                                                                                                                                                      type CreateRawTransaction struct {
                                                                                                                                                      	Result string `json:"result"`
                                                                                                                                                      	Error  Error  `json:"error"`
                                                                                                                                                      	ID     string `json:"id"`
                                                                                                                                                      }

                                                                                                                                                      type Currencies

                                                                                                                                                      type Currencies struct {
                                                                                                                                                      	Reservein           float64 `json:"reservein"`
                                                                                                                                                      	Nativein            float64 `json:"nativein"`
                                                                                                                                                      	Reserveout          float64 `json:"reserveout"`
                                                                                                                                                      	Lastconversionprice float64 `json:"lastconversionprice"`
                                                                                                                                                      	Viaconversionprice  float64 `json:"viaconversionprice"`
                                                                                                                                                      	Fees                float64 `json:"fees"`
                                                                                                                                                      	Conversionfees      float64 `json:"conversionfees"`
                                                                                                                                                      }

                                                                                                                                                        Currencies type

                                                                                                                                                        type CurrencyInfo

                                                                                                                                                        type CurrencyInfo struct {
                                                                                                                                                        	Name                 string        `json:"name"`
                                                                                                                                                        	Version              int           `json:"version"`
                                                                                                                                                        	Options              int           `json:"options"`
                                                                                                                                                        	Parent               string        `json:"parent"`
                                                                                                                                                        	Systemid             string        `json:"systemid"`
                                                                                                                                                        	Currencyid           string        `json:"currencyid"`
                                                                                                                                                        	Notarizationprotocol int           `json:"notarizationprotocol"`
                                                                                                                                                        	Proofprotocol        int           `json:"proofprotocol"`
                                                                                                                                                        	Idregistrationprice  int           `json:"idregistrationprice"`
                                                                                                                                                        	Idreferrallevels     int           `json:"idreferrallevels"`
                                                                                                                                                        	Minnotariesconfirm   int           `json:"minnotariesconfirm"`
                                                                                                                                                        	Billingperiod        int           `json:"billingperiod"`
                                                                                                                                                        	Notarizationreward   int           `json:"notarizationreward"`
                                                                                                                                                        	Startblock           int           `json:"startblock"`
                                                                                                                                                        	Endblock             int           `json:"endblock"`
                                                                                                                                                        	Currencies           []string      `json:"currencies"`
                                                                                                                                                        	Weights              []float64     `json:"weights"`
                                                                                                                                                        	Conversions          []float64     `json:"conversions"`
                                                                                                                                                        	Initialsupply        float64       `json:"initialsupply"`
                                                                                                                                                        	Prelaunchcarveout    float64       `json:"prelaunchcarveout"`
                                                                                                                                                        	Initialcontributions []float64     `json:"initialcontributions"`
                                                                                                                                                        	Preconversions       []float64     `json:"preconversions"`
                                                                                                                                                        	Eras                 []interface{} `json:"eras"`
                                                                                                                                                        }

                                                                                                                                                          CurrencyInfo type

                                                                                                                                                          type DEXAnonsend

                                                                                                                                                          type DEXAnonsend struct {
                                                                                                                                                          	Result struct {
                                                                                                                                                          		Timestamp    int    `json:"timestamp"`
                                                                                                                                                          		ID           int    `json:"id"`
                                                                                                                                                          		Hash         string `json:"hash"`
                                                                                                                                                          		TagA         string `json:"tagA"`
                                                                                                                                                          		TagB         string `json:"tagB"`
                                                                                                                                                          		Pubkey       string `json:"pubkey"`
                                                                                                                                                          		Payload      string `json:"payload"`
                                                                                                                                                          		Hex          int    `json:"hex"`
                                                                                                                                                          		Decrypted    string `json:"decrypted"`
                                                                                                                                                          		Decryptedhex int    `json:"decryptedhex"`
                                                                                                                                                          		Senderpub    string `json:"senderpub"`
                                                                                                                                                          		AmountA      string `json:"amountA"`
                                                                                                                                                          		AmountB      string `json:"amountB"`
                                                                                                                                                          		Priority     int    `json:"priority"`
                                                                                                                                                          		Recvtime     int    `json:"recvtime"`
                                                                                                                                                          		Cancelled    int    `json:"cancelled"`
                                                                                                                                                          	} `json:"result"`
                                                                                                                                                          	Error Error  `json:"error"`
                                                                                                                                                          	ID    string `json:"id"`
                                                                                                                                                          }

                                                                                                                                                            DEXAnonsend type

                                                                                                                                                            type DEXBroadcast

                                                                                                                                                            type DEXBroadcast struct {
                                                                                                                                                            	Result struct {
                                                                                                                                                            		Timestamp    int    `json:"timestamp"`
                                                                                                                                                            		ID           int    `json:"id"`
                                                                                                                                                            		Hash         string `json:"hash"`
                                                                                                                                                            		TagA         string `json:"tagA"`
                                                                                                                                                            		TagB         string `json:"tagB"`
                                                                                                                                                            		Pubkey       string `json:"pubkey"`
                                                                                                                                                            		Payload      string `json:"payload"`
                                                                                                                                                            		Hex          int    `json:"hex"`
                                                                                                                                                            		Decrypted    string `json:"decrypted"`
                                                                                                                                                            		Decryptedhex int    `json:"decryptedhex"`
                                                                                                                                                            		Senderpub    string `json:"senderpub"`
                                                                                                                                                            		AmountA      string `json:"amountA"`
                                                                                                                                                            		AmountB      string `json:"amountB"`
                                                                                                                                                            		Priority     int    `json:"priority"`
                                                                                                                                                            		Recvtime     int    `json:"recvtime"`
                                                                                                                                                            		Cancelled    int    `json:"cancelled"`
                                                                                                                                                            	} `json:"result"`
                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                            }

                                                                                                                                                              DEXBroadcast type

                                                                                                                                                              type DEXCancel

                                                                                                                                                              type DEXCancel struct {
                                                                                                                                                              	Result struct {
                                                                                                                                                              		Timestamp    int    `json:"timestamp"`
                                                                                                                                                              		ID           int    `json:"id"`
                                                                                                                                                              		Hash         string `json:"hash"`
                                                                                                                                                              		TagA         string `json:"tagA"`
                                                                                                                                                              		TagB         string `json:"tagB"`
                                                                                                                                                              		Pubkey       string `json:"pubkey"`
                                                                                                                                                              		Payload      string `json:"payload"`
                                                                                                                                                              		Hex          int    `json:"hex"`
                                                                                                                                                              		Decrypted    string `json:"decrypted"`
                                                                                                                                                              		Decryptedhex int    `json:"decryptedhex"`
                                                                                                                                                              		AmountA      string `json:"amountA"`
                                                                                                                                                              		AmountB      string `json:"amountB"`
                                                                                                                                                              		Priority     int    `json:"priority"`
                                                                                                                                                              		Recvtime     int    `json:"recvtime"`
                                                                                                                                                              		Cancelled    int    `json:"cancelled"`
                                                                                                                                                              	} `json:"result"`
                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                              }

                                                                                                                                                                DEXCancel type

                                                                                                                                                                type DEXGet

                                                                                                                                                                type DEXGet struct {
                                                                                                                                                                	Result struct {
                                                                                                                                                                		Timestamp    int    `json:"timestamp"`
                                                                                                                                                                		ID           int    `json:"id"`
                                                                                                                                                                		Hash         string `json:"hash"`
                                                                                                                                                                		TagA         string `json:"tagA"`
                                                                                                                                                                		TagB         string `json:"tagB"`
                                                                                                                                                                		Pubkey       string `json:"pubkey"`
                                                                                                                                                                		Payload      string `json:"payload"`
                                                                                                                                                                		Hex          int    `json:"hex"`
                                                                                                                                                                		Decrypted    string `json:"decrypted"`
                                                                                                                                                                		Decryptedhex int    `json:"decryptedhex"`
                                                                                                                                                                		Senderpub    string `json:"senderpub"`
                                                                                                                                                                		AmountA      string `json:"amountA"`
                                                                                                                                                                		AmountB      string `json:"amountB"`
                                                                                                                                                                		Priority     int    `json:"priority"`
                                                                                                                                                                		Recvtime     int    `json:"recvtime"`
                                                                                                                                                                		Cancelled    int    `json:"cancelled"`
                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                }

                                                                                                                                                                  DEXGet type

                                                                                                                                                                  type DEXList

                                                                                                                                                                  type DEXList struct {
                                                                                                                                                                  	Result struct {
                                                                                                                                                                  		Result  string `json:"result"`
                                                                                                                                                                  		Matches []struct {
                                                                                                                                                                  			Timestamp    int    `json:"timestamp"`
                                                                                                                                                                  			ID           int64  `json:"id"`
                                                                                                                                                                  			Hash         string `json:"hash"`
                                                                                                                                                                  			TagA         string `json:"tagA"`
                                                                                                                                                                  			TagB         string `json:"tagB"`
                                                                                                                                                                  			Pubkey       string `json:"pubkey"`
                                                                                                                                                                  			Payload      string `json:"payload"`
                                                                                                                                                                  			Hex          int    `json:"hex"`
                                                                                                                                                                  			Decrypted    string `json:"decrypted"`
                                                                                                                                                                  			Decryptedhex int    `json:"decryptedhex"`
                                                                                                                                                                  			Senderpub    string `json:"senderpub"`
                                                                                                                                                                  			Error        string `json:"error"`
                                                                                                                                                                  			AmountA      string `json:"amountA"`
                                                                                                                                                                  			AmountB      string `json:"amountB"`
                                                                                                                                                                  			Priority     int    `json:"priority"`
                                                                                                                                                                  			Recvtime     int    `json:"recvtime"`
                                                                                                                                                                  			Cancelled    int    `json:"cancelled"`
                                                                                                                                                                  			Anonmsg      string `json:"anonmsg,omitempty"`
                                                                                                                                                                  			Anonsender   string `json:"anonsender,omitempty"`
                                                                                                                                                                  		} `json:"matches"`
                                                                                                                                                                  		TagA   string `json:"tagA"`
                                                                                                                                                                  		TagB   string `json:"tagB"`
                                                                                                                                                                  		Pubkey string `json:"pubkey"`
                                                                                                                                                                  		N      int    `json:"n"`
                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                  }

                                                                                                                                                                    DEXList type

                                                                                                                                                                    type DEXOrderbook

                                                                                                                                                                    type DEXOrderbook struct {
                                                                                                                                                                    	Result struct {
                                                                                                                                                                    		Asks []struct {
                                                                                                                                                                    			Price      string `json:"price"`
                                                                                                                                                                    			Baseamount string `json:"baseamount"`
                                                                                                                                                                    			Relamount  string `json:"relamount"`
                                                                                                                                                                    			Priority   int    `json:"priority"`
                                                                                                                                                                    			Pubkey     string `json:"pubkey"`
                                                                                                                                                                    			Timestamp  int    `json:"timestamp"`
                                                                                                                                                                    			Hash       string `json:"hash"`
                                                                                                                                                                    			ID         int64  `json:"id"`
                                                                                                                                                                    		} `json:"asks"`
                                                                                                                                                                    		Bids []struct {
                                                                                                                                                                    			Price      string `json:"price"`
                                                                                                                                                                    			Baseamount string `json:"baseamount"`
                                                                                                                                                                    			Relamount  string `json:"relamount"`
                                                                                                                                                                    			Priority   int    `json:"priority"`
                                                                                                                                                                    			Pubkey     string `json:"pubkey"`
                                                                                                                                                                    			Timestamp  int    `json:"timestamp"`
                                                                                                                                                                    			Hash       string `json:"hash"`
                                                                                                                                                                    			ID         int64  `json:"id"`
                                                                                                                                                                    		} `json:"bids"`
                                                                                                                                                                    		Base string `json:"base"`
                                                                                                                                                                    		Rel  string `json:"rel"`
                                                                                                                                                                    	} `json:"result"`
                                                                                                                                                                    	Error Error  `json:"error"`
                                                                                                                                                                    	ID    string `json:"id"`
                                                                                                                                                                    }

                                                                                                                                                                      DEXOrderbook type

                                                                                                                                                                      type DEXPublish

                                                                                                                                                                      type DEXPublish struct {
                                                                                                                                                                      	Result struct {
                                                                                                                                                                      		Fname       string `json:"fname"`
                                                                                                                                                                      		ID          int    `json:"id"`
                                                                                                                                                                      		Senderpub   string `json:"senderpub"`
                                                                                                                                                                      		Filesize    int    `json:"filesize"`
                                                                                                                                                                      		Fragments   int    `json:"fragments"`
                                                                                                                                                                      		Numlocators int    `json:"numlocators"`
                                                                                                                                                                      		Filehash    string `json:"filehash"`
                                                                                                                                                                      		Checkhash   string `json:"checkhash"`
                                                                                                                                                                      		Result      string `json:"result"`
                                                                                                                                                                      	} `json:"result"`
                                                                                                                                                                      	Error Error  `json:"error"`
                                                                                                                                                                      	ID    string `json:"id"`
                                                                                                                                                                      }

                                                                                                                                                                        DEXPublish type

                                                                                                                                                                        type DEXSetPubKey

                                                                                                                                                                        type DEXSetPubKey struct {
                                                                                                                                                                        	Result struct {
                                                                                                                                                                        		Result            string `json:"result"`
                                                                                                                                                                        		PublishablePubkey string `json:"publishable_pubkey"`
                                                                                                                                                                        		Secpkey           string `json:"secpkey"`
                                                                                                                                                                        		Recvaddr          string `json:"recvaddr"`
                                                                                                                                                                        		RecvZaddr         string `json:"recvZaddr"`
                                                                                                                                                                        		Handle            string `json:"handle"`
                                                                                                                                                                        		Txpowbits         int    `json:"txpowbits"`
                                                                                                                                                                        		Vip               int    `json:"vip"`
                                                                                                                                                                        		Cmdpriority       int    `json:"cmdpriority"`
                                                                                                                                                                        		Perfstats         string `json:"perfstats"`
                                                                                                                                                                        	} `json:"result"`
                                                                                                                                                                        	Error Error  `json:"error"`
                                                                                                                                                                        	ID    string `json:"id"`
                                                                                                                                                                        }

                                                                                                                                                                          DEXSetPubKey type

                                                                                                                                                                          type DEXStats

                                                                                                                                                                          type DEXStats struct {
                                                                                                                                                                          	Result struct {
                                                                                                                                                                          		Result            string `json:"result"`
                                                                                                                                                                          		PublishablePubkey string `json:"publishable_pubkey"`
                                                                                                                                                                          		Secpkey           string `json:"secpkey"`
                                                                                                                                                                          		Recvaddr          string `json:"recvaddr"`
                                                                                                                                                                          		RecvZaddr         string `json:"recvZaddr"`
                                                                                                                                                                          		Handle            string `json:"handle"`
                                                                                                                                                                          		Txpowbits         int    `json:"txpowbits"`
                                                                                                                                                                          		Vip               int    `json:"vip"`
                                                                                                                                                                          		Cmdpriority       int    `json:"cmdpriority"`
                                                                                                                                                                          		Progress          int    `json:"progress"`
                                                                                                                                                                          		Perfstats         string `json:"perfstats"`
                                                                                                                                                                          	} `json:"result"`
                                                                                                                                                                          	Error Error  `json:"error"`
                                                                                                                                                                          	ID    string `json:"id"`
                                                                                                                                                                          }

                                                                                                                                                                            DEXStats type

                                                                                                                                                                            type DecodeRawTransaction

                                                                                                                                                                            type DecodeRawTransaction struct {
                                                                                                                                                                            	Result struct {
                                                                                                                                                                            		Txid     string `json:"txid"`
                                                                                                                                                                            		Size     int    `json:"size"`
                                                                                                                                                                            		Version  int    `json:"version"`
                                                                                                                                                                            		Locktime int    `json:"locktime"`
                                                                                                                                                                            		Vin      []struct {
                                                                                                                                                                            			Txid      string `json:"txid"`
                                                                                                                                                                            			Vout      int    `json:"vout"`
                                                                                                                                                                            			ScriptSig struct {
                                                                                                                                                                            				Asm string `json:"asm"`
                                                                                                                                                                            				Hex string `json:"hex"`
                                                                                                                                                                            			} `json:"scriptSig"`
                                                                                                                                                                            			Sequence int64 `json:"sequence"`
                                                                                                                                                                            		} `json:"vin"`
                                                                                                                                                                            		Vout []struct {
                                                                                                                                                                            			Value        float64 `json:"value"`
                                                                                                                                                                            			ValueSat     int     `json:"valueSat"`
                                                                                                                                                                            			N            int     `json:"n"`
                                                                                                                                                                            			ScriptPubKey struct {
                                                                                                                                                                            				Asm       string   `json:"asm"`
                                                                                                                                                                            				Hex       string   `json:"hex"`
                                                                                                                                                                            				ReqSigs   int      `json:"reqSigs"`
                                                                                                                                                                            				Type      string   `json:"type"`
                                                                                                                                                                            				Addresses []string `json:"addresses"`
                                                                                                                                                                            			} `json:"scriptPubKey"`
                                                                                                                                                                            		} `json:"vout"`
                                                                                                                                                                            		Vjoinsplit []interface{} `json:"vjoinsplit"`
                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                            }

                                                                                                                                                                            type DecodeScript

                                                                                                                                                                            type DecodeScript struct {
                                                                                                                                                                            	Result struct {
                                                                                                                                                                            		Asm  string `json:"asm"`
                                                                                                                                                                            		Type string `json:"type"`
                                                                                                                                                                            		P2Sh string `json:"p2sh"`
                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                            }

                                                                                                                                                                            type DisconnectNode

                                                                                                                                                                            type DisconnectNode struct {
                                                                                                                                                                            	Result string `json:"result"`
                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                            }

                                                                                                                                                                            type DumpPrivKey

                                                                                                                                                                            type DumpPrivKey struct {
                                                                                                                                                                            	Result string `json:"result"`
                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                            }

                                                                                                                                                                            type DumpWallet

                                                                                                                                                                            type DumpWallet struct {
                                                                                                                                                                            	Result string `json:"result"`
                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                            }

                                                                                                                                                                            type EncryptWallet

                                                                                                                                                                            type EncryptWallet struct {
                                                                                                                                                                            	Result string `json:"result"`
                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                            }

                                                                                                                                                                            type Error

                                                                                                                                                                            type Error struct {
                                                                                                                                                                            	Code    int    `json:"code"`
                                                                                                                                                                            	Message string `json:"message"`
                                                                                                                                                                            }

                                                                                                                                                                              Error data type to store/format the errors resturned from smart chain API queries

                                                                                                                                                                              type FaucetAddress

                                                                                                                                                                              type FaucetAddress struct {
                                                                                                                                                                              	Result struct {
                                                                                                                                                                              		Result          string `json:"result"`
                                                                                                                                                                              		FaucetCCaddress string `json:"FaucetCCaddress"`
                                                                                                                                                                              		Faucetmarker    string `json:"Faucetmarker"`
                                                                                                                                                                              		GatewaysPubkey  string `json:"GatewaysPubkey"`
                                                                                                                                                                              		FaucetCCassets  string `json:"FaucetCCassets"`
                                                                                                                                                                              		MyCCaddress     string `json:"myCCaddress"`
                                                                                                                                                                              		Myaddress       string `json:"myaddress"`
                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                              }

                                                                                                                                                                                FaucetAddress type

                                                                                                                                                                                type FaucetFund

                                                                                                                                                                                type FaucetFund struct {
                                                                                                                                                                                	Result struct {
                                                                                                                                                                                		Result string `json:"result"`
                                                                                                                                                                                		Hex    string `json:"hex"`
                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                }

                                                                                                                                                                                  FaucetFund type This should have been a `int` value or `float64` value. But since the API only accepts string, for now this is input as string.

                                                                                                                                                                                  type FaucetGet

                                                                                                                                                                                  type FaucetGet struct {
                                                                                                                                                                                  	Result struct {
                                                                                                                                                                                  		Result string `json:"result"`
                                                                                                                                                                                  		Hex    string `json:"hex"`
                                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                                  }

                                                                                                                                                                                    FaucetGet type

                                                                                                                                                                                    type FaucetInfo

                                                                                                                                                                                    type FaucetInfo struct {
                                                                                                                                                                                    	Result struct {
                                                                                                                                                                                    		Result  string `json:"result"`
                                                                                                                                                                                    		Name    string `json:"name"`
                                                                                                                                                                                    		Funding string `json:"funding"`
                                                                                                                                                                                    	} `json:"result"`
                                                                                                                                                                                    	Error Error  `json:"error"`
                                                                                                                                                                                    	ID    string `json:"id"`
                                                                                                                                                                                    }

                                                                                                                                                                                      FaucetInfo type This should have been a `int` value or `float64` value. But since the API only accepts string, for now this is input as string.

                                                                                                                                                                                      type FundRawTransaction

                                                                                                                                                                                      type FundRawTransaction struct {
                                                                                                                                                                                      	Result struct {
                                                                                                                                                                                      		Hex       string  `json:"hex"`
                                                                                                                                                                                      		Changepos int     `json:"changepos"`
                                                                                                                                                                                      		Fee       float64 `json:"fee"`
                                                                                                                                                                                      	} `json:"result"`
                                                                                                                                                                                      	Error Error  `json:"error"`
                                                                                                                                                                                      	ID    string `json:"id"`
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetAccount

                                                                                                                                                                                      type GetAccount struct {
                                                                                                                                                                                      	Result string `json:"result"`
                                                                                                                                                                                      	Error  Error  `json:"error"`
                                                                                                                                                                                      	ID     string `json:"id"`
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetAccountAddress

                                                                                                                                                                                      type GetAccountAddress struct {
                                                                                                                                                                                      	Result string `json:"result"`
                                                                                                                                                                                      	Error  Error  `json:"error"`
                                                                                                                                                                                      	ID     string `json:"id"`
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetAddedNodeInfo

                                                                                                                                                                                      type GetAddedNodeInfo struct {
                                                                                                                                                                                      	Result []struct {
                                                                                                                                                                                      		Addednode string `json:"addednode"`
                                                                                                                                                                                      		Connected bool   `json:"connected"`
                                                                                                                                                                                      		Addresses []struct {
                                                                                                                                                                                      			Address   string `json:"address"`
                                                                                                                                                                                      			Connected string `json:"connected"`
                                                                                                                                                                                      		} `json:"addresses"`
                                                                                                                                                                                      	} `json:"result"`
                                                                                                                                                                                      	Error Error  `json:"error"`
                                                                                                                                                                                      	ID    string `json:"id"`
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetAddressesByAccount

                                                                                                                                                                                      type GetAddressesByAccount struct {
                                                                                                                                                                                      	Result []string `json:"result"`
                                                                                                                                                                                      	Error  Error    `json:"error"`
                                                                                                                                                                                      	ID     string   `json:"id"`
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetBalance

                                                                                                                                                                                      type GetBalance struct {
                                                                                                                                                                                      	Result int64  `json:"result"`
                                                                                                                                                                                      	Error  Error  `json:"error"`
                                                                                                                                                                                      	ID     string `json:"id"`
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetBestBlockhash

                                                                                                                                                                                      type GetBestBlockhash struct {
                                                                                                                                                                                      	Result interface{} `json:"result"`
                                                                                                                                                                                      	Error  Error       `json:"error"`
                                                                                                                                                                                      	ID     string      `json:"id"`
                                                                                                                                                                                      }

                                                                                                                                                                                        GetBestBlockhash type

                                                                                                                                                                                        type GetBlock

                                                                                                                                                                                        type GetBlock struct {
                                                                                                                                                                                        	Result struct {
                                                                                                                                                                                        		Hash             string `json:"hash"`
                                                                                                                                                                                        		Validationtype   string `json:"validationtype"`
                                                                                                                                                                                        		Postarget        string `json:"postarget"`
                                                                                                                                                                                        		Poshashbh        string `json:"poshashbh"`
                                                                                                                                                                                        		Poshashtx        string `json:"poshashtx"`
                                                                                                                                                                                        		Possourcetxid    string `json:"possourcetxid"`
                                                                                                                                                                                        		Possourcevoutnum int    `json:"possourcevoutnum"`
                                                                                                                                                                                        		Posrewarddest    string `json:"posrewarddest"`
                                                                                                                                                                                        		Posrewardpk      string `json:"posrewardpk"`
                                                                                                                                                                                        		Postxddest       string `json:"postxddest"`
                                                                                                                                                                                        		Confirmations    int    `json:"confirmations"`
                                                                                                                                                                                        		Rawconfirmations int    `json:"rawconfirmations"`
                                                                                                                                                                                        		Size             int    `json:"size"`
                                                                                                                                                                                        		Height           int    `json:"height"`
                                                                                                                                                                                        		Version          int    `json:"version"`
                                                                                                                                                                                        		Merkleroot       string `json:"merkleroot"`
                                                                                                                                                                                        		Segid            int    `json:"segid"`
                                                                                                                                                                                        		Finalsaplingroot string `json:"finalsaplingroot"`
                                                                                                                                                                                        		Tx               []struct {
                                                                                                                                                                                        			Txid           string `json:"txid"`
                                                                                                                                                                                        			Overwintered   bool   `json:"overwintered"`
                                                                                                                                                                                        			Version        int    `json:"version"`
                                                                                                                                                                                        			Versiongroupid string `json:"versiongroupid"`
                                                                                                                                                                                        			Locktime       int    `json:"locktime"`
                                                                                                                                                                                        			Expiryheight   int    `json:"expiryheight"`
                                                                                                                                                                                        			Vin            []struct {
                                                                                                                                                                                        				Txid      string `json:"txid"`
                                                                                                                                                                                        				Vout      int    `json:"vout"`
                                                                                                                                                                                        				ScriptSig struct {
                                                                                                                                                                                        					Asm string `json:"asm"`
                                                                                                                                                                                        					Hex string `json:"hex"`
                                                                                                                                                                                        				} `json:"scriptSig"`
                                                                                                                                                                                        				Value    float64 `json:"value"`
                                                                                                                                                                                        				ValueSat int     `json:"valueSat"`
                                                                                                                                                                                        				Address  string  `json:"address"`
                                                                                                                                                                                        				Coinbase string  `json:"coinbase"`
                                                                                                                                                                                        				Sequence int64   `json:"sequence"`
                                                                                                                                                                                        			} `json:"vin"`
                                                                                                                                                                                        			Vout []struct {
                                                                                                                                                                                        				Value        float64 `json:"value"`
                                                                                                                                                                                        				ValueZat     int     `json:"valueZat"`
                                                                                                                                                                                        				ValueSat     int     `json:"valueSat"`
                                                                                                                                                                                        				N            int     `json:"n"`
                                                                                                                                                                                        				ScriptPubKey struct {
                                                                                                                                                                                        					Type            string `json:"type"`
                                                                                                                                                                                        					Identityprimary struct {
                                                                                                                                                                                        						Version             int         `json:"version"`
                                                                                                                                                                                        						Flags               int         `json:"flags"`
                                                                                                                                                                                        						Primaryaddresses    []string    `json:"primaryaddresses"`
                                                                                                                                                                                        						Minimumsignatures   int         `json:"minimumsignatures"`
                                                                                                                                                                                        						Identityaddress     string      `json:"identityaddress"`
                                                                                                                                                                                        						Parent              string      `json:"parent"`
                                                                                                                                                                                        						Name                string      `json:"name"`
                                                                                                                                                                                        						Contentmap          interface{} `json:"contentmap"`
                                                                                                                                                                                        						Revocationauthority string      `json:"revocationauthority"`
                                                                                                                                                                                        						Recoveryauthority   string      `json:"recoveryauthority"`
                                                                                                                                                                                        						Privateaddress      string      `json:"privateaddress"`
                                                                                                                                                                                        						Timelock            float64     `json:"timelock"`
                                                                                                                                                                                        					} `json:"identityprimary"`
                                                                                                                                                                                        					ReqSigs   int      `json:"reqSigs"`
                                                                                                                                                                                        					Addresses []string `json:"addresses"`
                                                                                                                                                                                        					Asm       string   `json:"asm"`
                                                                                                                                                                                        					Hex       string   `json:"hex"`
                                                                                                                                                                                        					Hec       string   `json:"hec"`
                                                                                                                                                                                        				} `json:"scriptPubKey"`
                                                                                                                                                                                        				SpentTxID   string `json:"spentTxId"`
                                                                                                                                                                                        				SpentIndex  int    `json:"spentIndex"`
                                                                                                                                                                                        				SpentHeight int    `json:"spentHeight"`
                                                                                                                                                                                        			} `json:"vout"`
                                                                                                                                                                                        			Vjoinsplit      []interface{} `json:"vjoinsplit"`
                                                                                                                                                                                        			ValueBalance    float64       `json:"valueBalance"`
                                                                                                                                                                                        			ValueBalanceZat int           `json:"valueBalanceZat"`
                                                                                                                                                                                        			VShieldedSpend  []interface{} `json:"vShieldedSpend"`
                                                                                                                                                                                        			VShieldedOutput []interface{} `json:"vShieldedOutput"`
                                                                                                                                                                                        		} `json:"tx"`
                                                                                                                                                                                        		Time       int     `json:"time"`
                                                                                                                                                                                        		Nonce      string  `json:"nonce"`
                                                                                                                                                                                        		Solution   string  `json:"solution"`
                                                                                                                                                                                        		Bits       string  `json:"bits"`
                                                                                                                                                                                        		Difficulty float64 `json:"difficulty"`
                                                                                                                                                                                        		Chainwork  string  `json:"chainwork"`
                                                                                                                                                                                        		Chainstake string  `json:"chainstake"`
                                                                                                                                                                                        		Anchor     string  `json:"anchor"`
                                                                                                                                                                                        		Blocktype  string  `json:"blocktype"`
                                                                                                                                                                                        		ValuePools []struct {
                                                                                                                                                                                        			ID            string  `json:"id"`
                                                                                                                                                                                        			Monitored     bool    `json:"monitored"`
                                                                                                                                                                                        			ChainValue    float64 `json:"chainValue"`
                                                                                                                                                                                        			ChainValueZat int64   `json:"chainValueZat"`
                                                                                                                                                                                        			ValueDelta    float64 `json:"valueDelta"`
                                                                                                                                                                                        			ValueDeltaZat int     `json:"valueDeltaZat"`
                                                                                                                                                                                        		} `json:"valuePools"`
                                                                                                                                                                                        		Previousblockhash string `json:"previousblockhash"`
                                                                                                                                                                                        		Nextblockhash     string `json:"nextblockhash"`
                                                                                                                                                                                        	} `json:"result"`
                                                                                                                                                                                        	Error Error  `json:"error"`
                                                                                                                                                                                        	ID    string `json:"id"`
                                                                                                                                                                                        }

                                                                                                                                                                                          GetBlock type

                                                                                                                                                                                          type GetBlockCount

                                                                                                                                                                                          type GetBlockCount struct {
                                                                                                                                                                                          	Result int64  `json:"result"`
                                                                                                                                                                                          	Error  Error  `json:"error"`
                                                                                                                                                                                          	ID     string `json:"id"`
                                                                                                                                                                                          }

                                                                                                                                                                                            GetBlockCount type

                                                                                                                                                                                            type GetBlockHash

                                                                                                                                                                                            type GetBlockHash struct {
                                                                                                                                                                                            	Result string `json:"result"`
                                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                                            }

                                                                                                                                                                                              GetBlockHash type

                                                                                                                                                                                              type GetBlockHeader

                                                                                                                                                                                              type GetBlockHeader struct {
                                                                                                                                                                                              	Result struct {
                                                                                                                                                                                              		Hash              string  `json:"hash"`
                                                                                                                                                                                              		Confirmations     int     `json:"confirmations"`
                                                                                                                                                                                              		Rawconfirmations  int     `json:"rawconfirmations"`
                                                                                                                                                                                              		Height            int     `json:"height"`
                                                                                                                                                                                              		Version           int     `json:"version"`
                                                                                                                                                                                              		Merkleroot        string  `json:"merkleroot"`
                                                                                                                                                                                              		Finalsaplingroot  string  `json:"finalsaplingroot"`
                                                                                                                                                                                              		Time              int     `json:"time"`
                                                                                                                                                                                              		Nonce             string  `json:"nonce"`
                                                                                                                                                                                              		Solution          string  `json:"solution"`
                                                                                                                                                                                              		Bits              string  `json:"bits"`
                                                                                                                                                                                              		Difficulty        float64 `json:"difficulty"`
                                                                                                                                                                                              		Chainwork         string  `json:"chainwork"`
                                                                                                                                                                                              		Segid             int     `json:"segid"`
                                                                                                                                                                                              		Previousblockhash string  `json:"previousblockhash"`
                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                              }

                                                                                                                                                                                                GetBlockHeader type

                                                                                                                                                                                                type GetBlockSubsidy

                                                                                                                                                                                                type GetBlockSubsidy struct {
                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                		Miner float64 `json:"miner"`
                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetBlockTemplate

                                                                                                                                                                                                type GetBlockTemplate struct {
                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                		Capabilities      []string `json:"capabilities"`
                                                                                                                                                                                                		Version           int      `json:"version"`
                                                                                                                                                                                                		Previousblockhash string   `json:"previousblockhash"`
                                                                                                                                                                                                		Transactions      []struct {
                                                                                                                                                                                                			Data    string        `json:"data"`
                                                                                                                                                                                                			Hash    string        `json:"hash"`
                                                                                                                                                                                                			Depends []interface{} `json:"depends"`
                                                                                                                                                                                                			Fee     int           `json:"fee"`
                                                                                                                                                                                                			Sigops  int           `json:"sigops"`
                                                                                                                                                                                                		} `json:"transactions"`
                                                                                                                                                                                                		Coinbasetxn struct {
                                                                                                                                                                                                			Data          string        `json:"data"`
                                                                                                                                                                                                			Hash          string        `json:"hash"`
                                                                                                                                                                                                			Depends       []interface{} `json:"depends"`
                                                                                                                                                                                                			Fee           int           `json:"fee"`
                                                                                                                                                                                                			Sigops        int           `json:"sigops"`
                                                                                                                                                                                                			Coinbasevalue int           `json:"coinbasevalue"`
                                                                                                                                                                                                			Required      bool          `json:"required"`
                                                                                                                                                                                                		} `json:"coinbasetxn"`
                                                                                                                                                                                                		Longpollid string   `json:"longpollid"`
                                                                                                                                                                                                		Target     string   `json:"target"`
                                                                                                                                                                                                		Mintime    int      `json:"mintime"`
                                                                                                                                                                                                		Mutable    []string `json:"mutable"`
                                                                                                                                                                                                		Noncerange string   `json:"noncerange"`
                                                                                                                                                                                                		Sigoplimit int      `json:"sigoplimit"`
                                                                                                                                                                                                		Sizelimit  int      `json:"sizelimit"`
                                                                                                                                                                                                		Curtime    int      `json:"curtime"`
                                                                                                                                                                                                		Bits       string   `json:"bits"`
                                                                                                                                                                                                		Height     int      `json:"height"`
                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetBlockchainInfo

                                                                                                                                                                                                type GetBlockchainInfo struct {
                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                		Chain                string  `json:"chain"`
                                                                                                                                                                                                		Blocks               int     `json:"blocks"`
                                                                                                                                                                                                		Headers              int     `json:"headers"`
                                                                                                                                                                                                		Bestblockhash        string  `json:"bestblockhash"`
                                                                                                                                                                                                		Difficulty           float64 `json:"difficulty"`
                                                                                                                                                                                                		Verificationprogress float64 `json:"verificationprogress"`
                                                                                                                                                                                                		Chainwork            string  `json:"chainwork"`
                                                                                                                                                                                                		Pruned               bool    `json:"pruned"`
                                                                                                                                                                                                		Commitments          int     `json:"commitments"`
                                                                                                                                                                                                		ValuePools           []struct {
                                                                                                                                                                                                			ID            string  `json:"id"`
                                                                                                                                                                                                			Monitored     bool    `json:"monitored"`
                                                                                                                                                                                                			ChainValue    float64 `json:"chainValue"`
                                                                                                                                                                                                			ChainValueZat int64   `json:"chainValueZat"`
                                                                                                                                                                                                		} `json:"valuePools"`
                                                                                                                                                                                                		Softforks []struct {
                                                                                                                                                                                                			ID      string `json:"id"`
                                                                                                                                                                                                			Version int    `json:"version"`
                                                                                                                                                                                                			Enforce struct {
                                                                                                                                                                                                				Status   bool `json:"status"`
                                                                                                                                                                                                				Found    int  `json:"found"`
                                                                                                                                                                                                				Required int  `json:"required"`
                                                                                                                                                                                                				Window   int  `json:"window"`
                                                                                                                                                                                                			} `json:"enforce"`
                                                                                                                                                                                                			Reject struct {
                                                                                                                                                                                                				Status   bool `json:"status"`
                                                                                                                                                                                                				Found    int  `json:"found"`
                                                                                                                                                                                                				Required int  `json:"required"`
                                                                                                                                                                                                				Window   int  `json:"window"`
                                                                                                                                                                                                			} `json:"reject"`
                                                                                                                                                                                                		} `json:"softforks"`
                                                                                                                                                                                                		Upgrades struct {
                                                                                                                                                                                                			FiveBa81B19 struct {
                                                                                                                                                                                                				Name             string `json:"name"`
                                                                                                                                                                                                				Activationheight int    `json:"activationheight"`
                                                                                                                                                                                                				Status           string `json:"status"`
                                                                                                                                                                                                				Info             string `json:"info"`
                                                                                                                                                                                                			} `json:"5ba81b19"`
                                                                                                                                                                                                			Seven6B809Bb struct {
                                                                                                                                                                                                				Name             string `json:"name"`
                                                                                                                                                                                                				Activationheight int    `json:"activationheight"`
                                                                                                                                                                                                				Status           string `json:"status"`
                                                                                                                                                                                                				Info             string `json:"info"`
                                                                                                                                                                                                			} `json:"76b809bb"`
                                                                                                                                                                                                		} `json:"upgrades"`
                                                                                                                                                                                                		Consensus struct {
                                                                                                                                                                                                			Chaintip  string `json:"chaintip"`
                                                                                                                                                                                                			Nextblock string `json:"nextblock"`
                                                                                                                                                                                                		} `json:"consensus"`
                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                }

                                                                                                                                                                                                  GetBlockchainInfo type

                                                                                                                                                                                                  type GetChainTips

                                                                                                                                                                                                  type GetChainTips struct {
                                                                                                                                                                                                  	Result []struct {
                                                                                                                                                                                                  		Height    int    `json:"height"`
                                                                                                                                                                                                  		Hash      string `json:"hash"`
                                                                                                                                                                                                  		Branchlen int    `json:"branchlen"`
                                                                                                                                                                                                  		Status    string `json:"status"`
                                                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                                                  }

                                                                                                                                                                                                    GetChainTips type

                                                                                                                                                                                                    type GetConnectionCount

                                                                                                                                                                                                    type GetConnectionCount struct {
                                                                                                                                                                                                    	Result int    `json:"result"`
                                                                                                                                                                                                    	Error  Error  `json:"error"`
                                                                                                                                                                                                    	ID     string `json:"id"`
                                                                                                                                                                                                    }

                                                                                                                                                                                                    type GetCurrency

                                                                                                                                                                                                    type GetCurrency struct {
                                                                                                                                                                                                    	Result struct {
                                                                                                                                                                                                    		Name                 string        `json:"name"`
                                                                                                                                                                                                    		Version              int           `json:"version"`
                                                                                                                                                                                                    		Options              int           `json:"options"`
                                                                                                                                                                                                    		Parent               string        `json:"parent"`
                                                                                                                                                                                                    		Systemid             string        `json:"systemid"`
                                                                                                                                                                                                    		Currencyid           string        `json:"currencyid"`
                                                                                                                                                                                                    		Notarizationprotocol int           `json:"notarizationprotocol"`
                                                                                                                                                                                                    		Proofprotocol        int           `json:"proofprotocol"`
                                                                                                                                                                                                    		Idregistrationprice  int           `json:"idregistrationprice"`
                                                                                                                                                                                                    		Idreferrallevels     int           `json:"idreferrallevels"`
                                                                                                                                                                                                    		Minnotariesconfirm   int           `json:"minnotariesconfirm"`
                                                                                                                                                                                                    		Billingperiod        int           `json:"billingperiod"`
                                                                                                                                                                                                    		Notarizationreward   int           `json:"notarizationreward"`
                                                                                                                                                                                                    		Startblock           int           `json:"startblock"`
                                                                                                                                                                                                    		Endblock             int           `json:"endblock"`
                                                                                                                                                                                                    		Currencies           []string      `json:"currencies"`
                                                                                                                                                                                                    		Weights              []float64     `json:"weights"`
                                                                                                                                                                                                    		Conversions          []float64     `json:"conversions"`
                                                                                                                                                                                                    		Initialsupply        float64       `json:"initialsupply"`
                                                                                                                                                                                                    		Prelaunchcarveout    float64       `json:"prelaunchcarveout"`
                                                                                                                                                                                                    		Initialcontributions []float64     `json:"initialcontributions"`
                                                                                                                                                                                                    		Preconversions       []float64     `json:"preconversions"`
                                                                                                                                                                                                    		Eras                 []interface{} `json:"eras"`
                                                                                                                                                                                                    		Definitiontxid       string        `json:"definitiontxid"`
                                                                                                                                                                                                    		Bestcurrencystate    struct {
                                                                                                                                                                                                    			Flags             int    `json:"flags"`
                                                                                                                                                                                                    			Currencyid        string `json:"currencyid"`
                                                                                                                                                                                                    			Reservecurrencies []struct {
                                                                                                                                                                                                    				Currencyid     string  `json:"currencyid"`
                                                                                                                                                                                                    				Weight         float64 `json:"weight"`
                                                                                                                                                                                                    				Reserves       float64 `json:"reserves"`
                                                                                                                                                                                                    				Priceinreserve float64 `json:"priceinreserve"`
                                                                                                                                                                                                    			} `json:"reservecurrencies"`
                                                                                                                                                                                                    			Initialsupply        float64               `json:"initialsupply"`
                                                                                                                                                                                                    			Emitted              float64               `json:"emitted"`
                                                                                                                                                                                                    			Supply               float64               `json:"supply"`
                                                                                                                                                                                                    			Currencies           map[string]Currencies `json:"currencies"`
                                                                                                                                                                                                    			Nativefees           int                   `json:"nativefees"`
                                                                                                                                                                                                    			Nativeconversionfees int                   `json:"nativeconversionfees"`
                                                                                                                                                                                                    		} `json:"bestcurrencystate"`
                                                                                                                                                                                                    	} `json:"result"`
                                                                                                                                                                                                    	Error Error  `json:"error"`
                                                                                                                                                                                                    	ID    string `json:"id"`
                                                                                                                                                                                                    }

                                                                                                                                                                                                      GetCurrency type

                                                                                                                                                                                                      type GetCurrencyConverter

                                                                                                                                                                                                      type GetCurrencyConverter struct {
                                                                                                                                                                                                      	CurrencyInfo     CurrencyInfo `json:"-"`
                                                                                                                                                                                                      	Lastnotarization struct {
                                                                                                                                                                                                      		Version             int    `json:"version"`
                                                                                                                                                                                                      		Currencyid          string `json:"currencyid"`
                                                                                                                                                                                                      		Notaryaddress       string `json:"notaryaddress"`
                                                                                                                                                                                                      		Notarizationheight  int    `json:"notarizationheight"`
                                                                                                                                                                                                      		Mmrroot             string `json:"mmrroot"`
                                                                                                                                                                                                      		Notarizationprehash string `json:"notarizationprehash"`
                                                                                                                                                                                                      		Work                string `json:"work"`
                                                                                                                                                                                                      		Stake               string `json:"stake"`
                                                                                                                                                                                                      		Currencystate       struct {
                                                                                                                                                                                                      			Flags             int    `json:"flags"`
                                                                                                                                                                                                      			Currencyid        string `json:"currencyid"`
                                                                                                                                                                                                      			Reservecurrencies []struct {
                                                                                                                                                                                                      				Currencyid     string  `json:"currencyid"`
                                                                                                                                                                                                      				Weight         float64 `json:"weight"`
                                                                                                                                                                                                      				Reserves       float64 `json:"reserves"`
                                                                                                                                                                                                      				Priceinreserve float64 `json:"priceinreserve"`
                                                                                                                                                                                                      			} `json:"reservecurrencies"`
                                                                                                                                                                                                      			Initialsupply        float64               `json:"initialsupply"`
                                                                                                                                                                                                      			Emitted              float64               `json:"emitted"`
                                                                                                                                                                                                      			Supply               float64               `json:"supply"`
                                                                                                                                                                                                      			Currencies           map[string]Currencies `json:"currencies"`
                                                                                                                                                                                                      			Nativefees           int64                 `json:"nativefees"`
                                                                                                                                                                                                      			Nativeconversionfees int64                 `json:"nativeconversionfees"`
                                                                                                                                                                                                      		} `json:"currencystate"`
                                                                                                                                                                                                      		Prevnotarization  string        `json:"prevnotarization"`
                                                                                                                                                                                                      		Prevheight        int           `json:"prevheight"`
                                                                                                                                                                                                      		Crossnotarization string        `json:"crossnotarization"`
                                                                                                                                                                                                      		Crossheight       int           `json:"crossheight"`
                                                                                                                                                                                                      		Nodes             []interface{} `json:"nodes"`
                                                                                                                                                                                                      	} `json:"lastnotarization"`
                                                                                                                                                                                                      	Multifractional struct {
                                                                                                                                                                                                      		Name                 string        `json:"name"`
                                                                                                                                                                                                      		Version              int           `json:"version"`
                                                                                                                                                                                                      		Options              int           `json:"options"`
                                                                                                                                                                                                      		Parent               string        `json:"parent"`
                                                                                                                                                                                                      		Systemid             string        `json:"systemid"`
                                                                                                                                                                                                      		Currencyid           string        `json:"currencyid"`
                                                                                                                                                                                                      		Notarizationprotocol int           `json:"notarizationprotocol"`
                                                                                                                                                                                                      		Proofprotocol        int           `json:"proofprotocol"`
                                                                                                                                                                                                      		Idregistrationprice  int           `json:"idregistrationprice"`
                                                                                                                                                                                                      		Idreferrallevels     int           `json:"idreferrallevels"`
                                                                                                                                                                                                      		Minnotariesconfirm   int           `json:"minnotariesconfirm"`
                                                                                                                                                                                                      		Billingperiod        int           `json:"billingperiod"`
                                                                                                                                                                                                      		Notarizationreward   int           `json:"notarizationreward"`
                                                                                                                                                                                                      		Startblock           int           `json:"startblock"`
                                                                                                                                                                                                      		Endblock             int           `json:"endblock"`
                                                                                                                                                                                                      		Currencies           []string      `json:"currencies"`
                                                                                                                                                                                                      		Weights              []float64     `json:"weights"`
                                                                                                                                                                                                      		Conversions          []float64     `json:"conversions"`
                                                                                                                                                                                                      		Initialsupply        float64       `json:"initialsupply"`
                                                                                                                                                                                                      		Prelaunchcarveout    float64       `json:"prelaunchcarveout"`
                                                                                                                                                                                                      		Initialcontributions []float64     `json:"initialcontributions"`
                                                                                                                                                                                                      		Preconversions       []float64     `json:"preconversions"`
                                                                                                                                                                                                      		Eras                 []interface{} `json:"eras"`
                                                                                                                                                                                                      	} `json:"multifractional,omitempty"`
                                                                                                                                                                                                      }

                                                                                                                                                                                                        GetCurrencyConverter type

                                                                                                                                                                                                        type GetCurrencyConverters

                                                                                                                                                                                                        type GetCurrencyConverters struct {
                                                                                                                                                                                                        	Result []GetCurrencyConverter `json:"result"`
                                                                                                                                                                                                        	Error  Error                  `json:"error"`
                                                                                                                                                                                                        	ID     string                 `json:"id"`
                                                                                                                                                                                                        }

                                                                                                                                                                                                          GetCurrencyConverters array type

                                                                                                                                                                                                          type GetCurrencyState

                                                                                                                                                                                                          type GetCurrencyState struct {
                                                                                                                                                                                                          	Result struct {
                                                                                                                                                                                                          		Height        int `json:"height"`
                                                                                                                                                                                                          		Blocktime     int `json:"blocktime"`
                                                                                                                                                                                                          		Currencystate struct {
                                                                                                                                                                                                          			Flags         int     `json:"flags"`
                                                                                                                                                                                                          			Currencyid    string  `json:"currencyid"`
                                                                                                                                                                                                          			Initialsupply float64 `json:"initialsupply"`
                                                                                                                                                                                                          			Emitted       float64 `json:"emitted"`
                                                                                                                                                                                                          			Supply        float64 `json:"supply"`
                                                                                                                                                                                                          			Currencies    struct {
                                                                                                                                                                                                          			} `json:"currencies"`
                                                                                                                                                                                                          			Nativefees           int `json:"nativefees"`
                                                                                                                                                                                                          			Nativeconversionfees int `json:"nativeconversionfees"`
                                                                                                                                                                                                          		} `json:"currencystate"`
                                                                                                                                                                                                          	} `json:"result"`
                                                                                                                                                                                                          	Error Error  `json:"error"`
                                                                                                                                                                                                          	ID    string `json:"id"`
                                                                                                                                                                                                          }

                                                                                                                                                                                                            GetCurrencyState type

                                                                                                                                                                                                            type GetDeprecationInfo

                                                                                                                                                                                                            type GetDeprecationInfo struct {
                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                            		Version           int    `json:"version"`
                                                                                                                                                                                                            		Subversion        string `json:"subversion"`
                                                                                                                                                                                                            		Deprecationheight int    `json:"deprecationheight"`
                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type GetDifficulty

                                                                                                                                                                                                            type GetDifficulty struct {
                                                                                                                                                                                                            	Result float64 `json:"result"`
                                                                                                                                                                                                            	Error  Error   `json:"error"`
                                                                                                                                                                                                            	ID     string  `json:"id"`
                                                                                                                                                                                                            }

                                                                                                                                                                                                              GetDifficulty type

                                                                                                                                                                                                              type GetExports

                                                                                                                                                                                                              type GetExports struct {
                                                                                                                                                                                                              	Result []struct {
                                                                                                                                                                                                              		Blockheight int    `json:"blockheight"`
                                                                                                                                                                                                              		Exportid    string `json:"exportid"`
                                                                                                                                                                                                              		Description struct {
                                                                                                                                                                                                              			Version          int                `json:"version"`
                                                                                                                                                                                                              			Exportcurrencyid string             `json:"exportcurrencyid"`
                                                                                                                                                                                                              			Numinputs        int                `json:"numinputs"`
                                                                                                                                                                                                              			Totalamounts     map[string]float64 `json:"totalamounts"`
                                                                                                                                                                                                              			Totalfees        map[string]float64 `json:"totalfees"`
                                                                                                                                                                                                              		} `json:"description"`
                                                                                                                                                                                                              		Transfers []struct {
                                                                                                                                                                                                              			Version               int     `json:"version"`
                                                                                                                                                                                                              			Currencyid            string  `json:"currencyid"`
                                                                                                                                                                                                              			Value                 float64 `json:"value"`
                                                                                                                                                                                                              			Flags                 int     `json:"flags"`
                                                                                                                                                                                                              			Preconvert            bool    `json:"preconvert,omitempty"`
                                                                                                                                                                                                              			Fees                  float64 `json:"fees"`
                                                                                                                                                                                                              			Destinationcurrencyid string  `json:"destinationcurrencyid"`
                                                                                                                                                                                                              			Destination           string  `json:"destination"`
                                                                                                                                                                                                              			Feeoutput             bool    `json:"feeoutput,omitempty"`
                                                                                                                                                                                                              		} `json:"transfers"`
                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                              }

                                                                                                                                                                                                                GetExports type

                                                                                                                                                                                                                type GetIdentity

                                                                                                                                                                                                                type GetIdentity struct {
                                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                                		Identity struct {
                                                                                                                                                                                                                			Version           int      `json:"version"`
                                                                                                                                                                                                                			Flags             int      `json:"flags"`
                                                                                                                                                                                                                			Primaryaddresses  []string `json:"primaryaddresses"`
                                                                                                                                                                                                                			Minimumsignatures int      `json:"minimumsignatures"`
                                                                                                                                                                                                                			Identityaddress   string   `json:"identityaddress"`
                                                                                                                                                                                                                			Parent            string   `json:"parent"`
                                                                                                                                                                                                                			Name              string   `json:"name"`
                                                                                                                                                                                                                			Contentmap        struct {
                                                                                                                                                                                                                			} `json:"contentmap"`
                                                                                                                                                                                                                			Revocationauthority string `json:"revocationauthority"`
                                                                                                                                                                                                                			Recoveryauthority   string `json:"recoveryauthority"`
                                                                                                                                                                                                                			Privateaddress      string `json:"privateaddress"`
                                                                                                                                                                                                                			Timelock            int    `json:"timelock"`
                                                                                                                                                                                                                		} `json:"identity"`
                                                                                                                                                                                                                		Status      string `json:"status"`
                                                                                                                                                                                                                		Canspendfor bool   `json:"canspendfor"`
                                                                                                                                                                                                                		Cansignfor  bool   `json:"cansignfor"`
                                                                                                                                                                                                                		Blockheight int    `json:"blockheight"`
                                                                                                                                                                                                                		Txid        string `json:"txid"`
                                                                                                                                                                                                                		Vout        int    `json:"vout"`
                                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  GetIdentity type

                                                                                                                                                                                                                  type GetImports

                                                                                                                                                                                                                  type GetImports struct {
                                                                                                                                                                                                                  	Result []struct {
                                                                                                                                                                                                                  		Blockheight int    `json:"blockheight"`
                                                                                                                                                                                                                  		Importid    string `json:"importid"`
                                                                                                                                                                                                                  		Description struct {
                                                                                                                                                                                                                  			Version          int                `json:"version"`
                                                                                                                                                                                                                  			Sourcesystemid   string             `json:"sourcesystemid"`
                                                                                                                                                                                                                  			Importcurrencyid string             `json:"importcurrencyid"`
                                                                                                                                                                                                                  			Valuein          map[string]float64 `json:"valuein"`
                                                                                                                                                                                                                  			Tokensout        map[string]float64 `json:"tokensout"`
                                                                                                                                                                                                                  		} `json:"description"`
                                                                                                                                                                                                                  		Transfers []struct {
                                                                                                                                                                                                                  			Version               int     `json:"version"`
                                                                                                                                                                                                                  			Currencyid            string  `json:"currencyid"`
                                                                                                                                                                                                                  			Value                 float64 `json:"value"`
                                                                                                                                                                                                                  			Flags                 int     `json:"flags"`
                                                                                                                                                                                                                  			Preconvert            bool    `json:"preconvert,omitempty"`
                                                                                                                                                                                                                  			Fees                  float64 `json:"fees"`
                                                                                                                                                                                                                  			Destinationcurrencyid string  `json:"destinationcurrencyid"`
                                                                                                                                                                                                                  			Destination           string  `json:"destination"`
                                                                                                                                                                                                                  			Feeoutput             bool    `json:"feeoutput,omitempty"`
                                                                                                                                                                                                                  		} `json:"transfers"`
                                                                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    GetImports type

                                                                                                                                                                                                                    type GetInfo

                                                                                                                                                                                                                    type GetInfo struct {
                                                                                                                                                                                                                    	Result struct {
                                                                                                                                                                                                                    		Version             int     `json:"version"`
                                                                                                                                                                                                                    		Protocolversion     int     `json:"protocolversion"`
                                                                                                                                                                                                                    		KMDversion          string  `json:"KMDversion"`
                                                                                                                                                                                                                    		VRSCversion         string  `rethinkdb:"VRSCversion"`
                                                                                                                                                                                                                    		Notarized           int     `json:"notarized"`
                                                                                                                                                                                                                    		PrevMoMheight       int     `json:"prevMoMheight"`
                                                                                                                                                                                                                    		Notarizedhash       string  `json:"notarizedhash"`
                                                                                                                                                                                                                    		Notarizedtxid       string  `json:"notarizedtxid"`
                                                                                                                                                                                                                    		NotarizedtxidHeight string  `json:"notarizedtxid_height"`
                                                                                                                                                                                                                    		KMDnotarizedHeight  int     `json:"KMDnotarized_height"`
                                                                                                                                                                                                                    		NotarizedConfirms   int     `json:"notarized_confirms"`
                                                                                                                                                                                                                    		Walletversion       int     `json:"walletversion"`
                                                                                                                                                                                                                    		Balance             float64 `json:"balance"`
                                                                                                                                                                                                                    		Blocks              int     `json:"blocks"`
                                                                                                                                                                                                                    		Longestchain        int     `json:"longestchain"`
                                                                                                                                                                                                                    		Timeoffset          int     `json:"timeoffset"`
                                                                                                                                                                                                                    		Tiptime             int     `json:"tiptime"`
                                                                                                                                                                                                                    		Connections         int     `json:"connections"`
                                                                                                                                                                                                                    		Proxy               string  `json:"proxy"`
                                                                                                                                                                                                                    		Difficulty          float64 `json:"difficulty"`
                                                                                                                                                                                                                    		Testnet             bool    `json:"testnet"`
                                                                                                                                                                                                                    		Keypoololdest       int     `json:"keypoololdest"`
                                                                                                                                                                                                                    		Keypoolsize         int     `json:"keypoolsize"`
                                                                                                                                                                                                                    		Paytxfee            float64 `json:"paytxfee"`
                                                                                                                                                                                                                    		Relayfee            float64 `json:"relayfee"`
                                                                                                                                                                                                                    		Errors              string  `json:"errors"`
                                                                                                                                                                                                                    		CCid                int     `json:"CCid"`
                                                                                                                                                                                                                    		Name                string  `json:"name"`
                                                                                                                                                                                                                    		P2Pport             int     `json:"p2pport"`
                                                                                                                                                                                                                    		Rpcport             int     `json:"rpcport"`
                                                                                                                                                                                                                    		Magic               int     `json:"magic"`
                                                                                                                                                                                                                    		Premine             int     `json:"premine"`
                                                                                                                                                                                                                    		Reward              int64   `json:"reward"`
                                                                                                                                                                                                                    		Halving             int     `json:"halving"`
                                                                                                                                                                                                                    		Decay               string  `json:"decay"`
                                                                                                                                                                                                                    		Endsubsidy          string  `json:"endsubsidy"`
                                                                                                                                                                                                                    		Isreserve           string  `json:"isreserve"`
                                                                                                                                                                                                                    		Veruspos            int     `json:"veruspos"`
                                                                                                                                                                                                                    		Commission          int     `json:"commission"`
                                                                                                                                                                                                                    	} `json:"result"`
                                                                                                                                                                                                                    	Error Error  `json:"error"`
                                                                                                                                                                                                                    	ID    string `json:"id"`
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      GetInfo struct type to store getinfo API output

                                                                                                                                                                                                                      type GetInitialCurrencyState

                                                                                                                                                                                                                      type GetInitialCurrencyState struct {
                                                                                                                                                                                                                      	Result struct {
                                                                                                                                                                                                                      		Flags             int    `json:"flags"`
                                                                                                                                                                                                                      		Currencyid        string `json:"currencyid"`
                                                                                                                                                                                                                      		Reservecurrencies []struct {
                                                                                                                                                                                                                      			Currencyid     string  `json:"currencyid"`
                                                                                                                                                                                                                      			Weight         float64 `json:"weight"`
                                                                                                                                                                                                                      			Reserves       float64 `json:"reserves"`
                                                                                                                                                                                                                      			Priceinreserve float64 `json:"priceinreserve"`
                                                                                                                                                                                                                      		} `json:"reservecurrencies"`
                                                                                                                                                                                                                      		Initialsupply        float64               `json:"initialsupply"`
                                                                                                                                                                                                                      		Emitted              float64               `json:"emitted"`
                                                                                                                                                                                                                      		Supply               float64               `json:"supply"`
                                                                                                                                                                                                                      		Currencies           map[string]Currencies `json:"currencies"`
                                                                                                                                                                                                                      		Nativefees           int64                 `json:"nativefees"`
                                                                                                                                                                                                                      		Nativeconversionfees int64                 `json:"nativeconversionfees"`
                                                                                                                                                                                                                      	} `json:"result"`
                                                                                                                                                                                                                      	Error Error  `json:"error"`
                                                                                                                                                                                                                      	ID    string `json:"id"`
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        GetInitialCurrencyState type

                                                                                                                                                                                                                        type GetLastImportin

                                                                                                                                                                                                                        type GetLastImportin struct {
                                                                                                                                                                                                                        	Result struct {
                                                                                                                                                                                                                        		Lastimporttransaction     string             `json:"lastimporttransaction"`
                                                                                                                                                                                                                        		Lastconfirmednotarization string             `json:"lastconfirmednotarization"`
                                                                                                                                                                                                                        		Importtxtemplate          string             `json:"importtxtemplate"`
                                                                                                                                                                                                                        		Nativeimportavailable     int64              `json:"nativeimportavailable"`
                                                                                                                                                                                                                        		Tokenimportavailable      map[string]float64 `json:"tokenimportavailable"`
                                                                                                                                                                                                                        	} `json:"result"`
                                                                                                                                                                                                                        	Error Error  `json:"error"`
                                                                                                                                                                                                                        	ID    string `json:"id"`
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          GetLastImportin type

                                                                                                                                                                                                                          type GetLocalSolps

                                                                                                                                                                                                                          type GetLocalSolps struct {
                                                                                                                                                                                                                          	Result int    `json:"result"`
                                                                                                                                                                                                                          	Error  Error  `json:"error"`
                                                                                                                                                                                                                          	ID     string `json:"id"`
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                          type GetMempoolInfo

                                                                                                                                                                                                                          type GetMempoolInfo struct {
                                                                                                                                                                                                                          	Result struct {
                                                                                                                                                                                                                          		Size  int `json:"size"`
                                                                                                                                                                                                                          		Bytes int `json:"bytes"`
                                                                                                                                                                                                                          		Usage int `json:"usage"`
                                                                                                                                                                                                                          	} `json:"result"`
                                                                                                                                                                                                                          	Error Error  `json:"error"`
                                                                                                                                                                                                                          	ID    string `json:"id"`
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            GetMempoolInfo type

                                                                                                                                                                                                                            type GetMiningInfo

                                                                                                                                                                                                                            type GetMiningInfo struct {
                                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                                            		Blocks           int     `json:"blocks"`
                                                                                                                                                                                                                            		Currentblocksize int     `json:"currentblocksize"`
                                                                                                                                                                                                                            		Currentblocktx   int     `json:"currentblocktx"`
                                                                                                                                                                                                                            		Difficulty       float64 `json:"difficulty"`
                                                                                                                                                                                                                            		Errors           string  `json:"errors"`
                                                                                                                                                                                                                            		Genproclimit     int     `json:"genproclimit"`
                                                                                                                                                                                                                            		Localsolps       int     `json:"localsolps"`
                                                                                                                                                                                                                            		Networksolps     int     `json:"networksolps"`
                                                                                                                                                                                                                            		Networkhashps    int     `json:"networkhashps"`
                                                                                                                                                                                                                            		Pooledtx         int     `json:"pooledtx"`
                                                                                                                                                                                                                            		Testnet          bool    `json:"testnet"`
                                                                                                                                                                                                                            		Chain            string  `json:"chain"`
                                                                                                                                                                                                                            		Generate         bool    `json:"generate"`
                                                                                                                                                                                                                            		Numthreads       int     `json:"numthreads"`
                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type GetNetTotals

                                                                                                                                                                                                                            type GetNetTotals struct {
                                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                                            		Totalbytesrecv int   `json:"totalbytesrecv"`
                                                                                                                                                                                                                            		Totalbytessent int   `json:"totalbytessent"`
                                                                                                                                                                                                                            		Timemillis     int64 `json:"timemillis"`
                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type GetNetworkHashps

                                                                                                                                                                                                                            type GetNetworkHashps struct {
                                                                                                                                                                                                                            	Result int    `json:"result"`
                                                                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type GetNetworkInfo

                                                                                                                                                                                                                            type GetNetworkInfo struct {
                                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                                            		Version         int    `json:"version"`
                                                                                                                                                                                                                            		Subversion      string `json:"subversion"`
                                                                                                                                                                                                                            		Protocolversion int    `json:"protocolversion"`
                                                                                                                                                                                                                            		Localservices   string `json:"localservices"`
                                                                                                                                                                                                                            		Timeoffset      int    `json:"timeoffset"`
                                                                                                                                                                                                                            		Connections     int    `json:"connections"`
                                                                                                                                                                                                                            		Networks        []struct {
                                                                                                                                                                                                                            			Name                      string `json:"name"`
                                                                                                                                                                                                                            			Limited                   bool   `json:"limited"`
                                                                                                                                                                                                                            			Reachable                 bool   `json:"reachable"`
                                                                                                                                                                                                                            			Proxy                     string `json:"proxy"`
                                                                                                                                                                                                                            			ProxyRandomizeCredentials bool   `json:"proxy_randomize_credentials"`
                                                                                                                                                                                                                            		} `json:"networks"`
                                                                                                                                                                                                                            		Relayfee       float64       `json:"relayfee"`
                                                                                                                                                                                                                            		Localaddresses []interface{} `json:"localaddresses"`
                                                                                                                                                                                                                            		Warnings       string        `json:"warnings"`
                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type GetNetworkSolps

                                                                                                                                                                                                                            type GetNetworkSolps struct {
                                                                                                                                                                                                                            	Result int    `json:"result"`
                                                                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type GetNewAddress

                                                                                                                                                                                                                            type GetNewAddress struct {
                                                                                                                                                                                                                            	Result string `json:"result"`
                                                                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type GetNotarizationData

                                                                                                                                                                                                                            type GetNotarizationData struct {
                                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                                            		Version       int `json:"version"`
                                                                                                                                                                                                                            		Notarizations []struct {
                                                                                                                                                                                                                            			Index        int    `json:"index"`
                                                                                                                                                                                                                            			Txid         string `json:"txid"`
                                                                                                                                                                                                                            			Notarization struct {
                                                                                                                                                                                                                            				Version             int    `json:"version"`
                                                                                                                                                                                                                            				Currencyid          string `json:"currencyid"`
                                                                                                                                                                                                                            				Notaryaddress       string `json:"notaryaddress"`
                                                                                                                                                                                                                            				Notarizationheight  int    `json:"notarizationheight"`
                                                                                                                                                                                                                            				Mmrroot             string `json:"mmrroot"`
                                                                                                                                                                                                                            				Notarizationprehash string `json:"notarizationprehash"`
                                                                                                                                                                                                                            				Work                string `json:"work"`
                                                                                                                                                                                                                            				Stake               string `json:"stake"`
                                                                                                                                                                                                                            				Currencystate       struct {
                                                                                                                                                                                                                            					Flags             int    `json:"flags"`
                                                                                                                                                                                                                            					Currencyid        string `json:"currencyid"`
                                                                                                                                                                                                                            					Reservecurrencies []struct {
                                                                                                                                                                                                                            						Currencyid     string  `json:"currencyid"`
                                                                                                                                                                                                                            						Weight         float64 `json:"weight"`
                                                                                                                                                                                                                            						Reserves       float64 `json:"reserves"`
                                                                                                                                                                                                                            						Priceinreserve float64 `json:"priceinreserve"`
                                                                                                                                                                                                                            					} `json:"reservecurrencies"`
                                                                                                                                                                                                                            					Initialsupply        float64               `json:"initialsupply"`
                                                                                                                                                                                                                            					Emitted              float64               `json:"emitted"`
                                                                                                                                                                                                                            					Supply               float64               `json:"supply"`
                                                                                                                                                                                                                            					Currencies           map[string]Currencies `json:"currencies"`
                                                                                                                                                                                                                            					Nativefees           int                   `json:"nativefees"`
                                                                                                                                                                                                                            					Nativeconversionfees int                   `json:"nativeconversionfees"`
                                                                                                                                                                                                                            				} `json:"currencystate"`
                                                                                                                                                                                                                            				Prevnotarization  string        `json:"prevnotarization"`
                                                                                                                                                                                                                            				Prevheight        int           `json:"prevheight"`
                                                                                                                                                                                                                            				Crossnotarization string        `json:"crossnotarization"`
                                                                                                                                                                                                                            				Crossheight       int           `json:"crossheight"`
                                                                                                                                                                                                                            				Nodes             []interface{} `json:"nodes"`
                                                                                                                                                                                                                            			} `json:"notarization"`
                                                                                                                                                                                                                            		} `json:"notarizations"`
                                                                                                                                                                                                                            		Forks               [][]int `json:"forks"`
                                                                                                                                                                                                                            		Lastconfirmedheight int     `json:"lastconfirmedheight"`
                                                                                                                                                                                                                            		Lastconfirmed       int     `json:"lastconfirmed"`
                                                                                                                                                                                                                            		Bestchain           int     `json:"bestchain"`
                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              GetNotarizationData type

                                                                                                                                                                                                                              type GetPeerInfo

                                                                                                                                                                                                                              type GetPeerInfo struct {
                                                                                                                                                                                                                              	Result []struct {
                                                                                                                                                                                                                              		ID             int           `json:"id"`
                                                                                                                                                                                                                              		Addr           string        `json:"addr"`
                                                                                                                                                                                                                              		Addrlocal      string        `json:"addrlocal"`
                                                                                                                                                                                                                              		Services       string        `json:"services"`
                                                                                                                                                                                                                              		Lastsend       int           `json:"lastsend"`
                                                                                                                                                                                                                              		Lastrecv       int           `json:"lastrecv"`
                                                                                                                                                                                                                              		Bytessent      int           `json:"bytessent"`
                                                                                                                                                                                                                              		Bytesrecv      int           `json:"bytesrecv"`
                                                                                                                                                                                                                              		Conntime       int           `json:"conntime"`
                                                                                                                                                                                                                              		Timeoffset     int           `json:"timeoffset"`
                                                                                                                                                                                                                              		Pingtime       float64       `json:"pingtime"`
                                                                                                                                                                                                                              		Version        int           `json:"version"`
                                                                                                                                                                                                                              		Subver         string        `json:"subver"`
                                                                                                                                                                                                                              		Inbound        bool          `json:"inbound"`
                                                                                                                                                                                                                              		Startingheight int           `json:"startingheight"`
                                                                                                                                                                                                                              		Banscore       int           `json:"banscore"`
                                                                                                                                                                                                                              		SyncedHeaders  int           `json:"synced_headers"`
                                                                                                                                                                                                                              		SyncedBlocks   int           `json:"synced_blocks"`
                                                                                                                                                                                                                              		Inflight       []interface{} `json:"inflight"`
                                                                                                                                                                                                                              		Whitelisted    bool          `json:"whitelisted"`
                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                              type GetRawChangeAddress

                                                                                                                                                                                                                              type GetRawChangeAddress struct {
                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                              type GetRawMempoolFalse

                                                                                                                                                                                                                              type GetRawMempoolFalse struct {
                                                                                                                                                                                                                              	Result []string `json:"result"`
                                                                                                                                                                                                                              	Error  Error    `json:"error"`
                                                                                                                                                                                                                              	ID     string   `json:"id"`
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                GetRawMempoolFalse type

                                                                                                                                                                                                                                type GetRawMempoolTrue

                                                                                                                                                                                                                                type GetRawMempoolTrue struct {
                                                                                                                                                                                                                                	Result map[string]RawMempoolTrue `json:"result"`
                                                                                                                                                                                                                                	Error  Error                     `json:"error"`
                                                                                                                                                                                                                                	ID     string                    `json:"id"`
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  GetRawMempoolTrue type

                                                                                                                                                                                                                                  type GetRawTransaction

                                                                                                                                                                                                                                  type GetRawTransaction struct {
                                                                                                                                                                                                                                  	Result string `json:"result"`
                                                                                                                                                                                                                                  	Error  Error  `json:"error"`
                                                                                                                                                                                                                                  	ID     string `json:"id"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                  type GetRawTransactionDetailed

                                                                                                                                                                                                                                  type GetRawTransactionDetailed struct {
                                                                                                                                                                                                                                  	Result GetRawTransactionFull `json:"result"`
                                                                                                                                                                                                                                  	Error  Error                 `json:"error"`
                                                                                                                                                                                                                                  	ID     string                `json:"id"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                  type GetRawTransactionFull

                                                                                                                                                                                                                                  type GetRawTransactionFull struct {
                                                                                                                                                                                                                                  	Hex          string `json:"hex"`
                                                                                                                                                                                                                                  	Txid         string `json:"txid"`
                                                                                                                                                                                                                                  	Overwintered bool   `json:"overwintered"`
                                                                                                                                                                                                                                  	Version      int    `json:"version"`
                                                                                                                                                                                                                                  	Locktime     int    `json:"locktime"`
                                                                                                                                                                                                                                  	Vin          []struct {
                                                                                                                                                                                                                                  		Txid      string `json:"txid"`
                                                                                                                                                                                                                                  		Vout      int    `json:"vout"`
                                                                                                                                                                                                                                  		Address   string `json:"address"`
                                                                                                                                                                                                                                  		ScriptSig struct {
                                                                                                                                                                                                                                  			Asm string `json:"asm"`
                                                                                                                                                                                                                                  			Hex string `json:"hex"`
                                                                                                                                                                                                                                  		} `json:"scriptSig"`
                                                                                                                                                                                                                                  		Sequence int64 `json:"sequence"`
                                                                                                                                                                                                                                  	} `json:"vin"`
                                                                                                                                                                                                                                  	Vout []struct {
                                                                                                                                                                                                                                  		Value        float64 `json:"value"`
                                                                                                                                                                                                                                  		Interest     float64 `json:"interest"`
                                                                                                                                                                                                                                  		ValueSat     int64   `json:"valueSat"`
                                                                                                                                                                                                                                  		N            int     `json:"n"`
                                                                                                                                                                                                                                  		ScriptPubKey struct {
                                                                                                                                                                                                                                  			Asm       string   `json:"asm"`
                                                                                                                                                                                                                                  			Hex       string   `json:"hex"`
                                                                                                                                                                                                                                  			ReqSigs   int      `json:"reqSigs"`
                                                                                                                                                                                                                                  			Type      string   `json:"type"`
                                                                                                                                                                                                                                  			Addresses []string `json:"addresses"`
                                                                                                                                                                                                                                  		} `json:"scriptPubKey"`
                                                                                                                                                                                                                                  	} `json:"vout"`
                                                                                                                                                                                                                                  	Vjoinsplit       []interface{} `json:"vjoinsplit"`
                                                                                                                                                                                                                                  	Blockhash        string        `json:"blockhash"`
                                                                                                                                                                                                                                  	Height           int           `json:"height"`
                                                                                                                                                                                                                                  	Confirmations    int           `json:"confirmations"`
                                                                                                                                                                                                                                  	Rawconfirmations int           `json:"rawconfirmations"`
                                                                                                                                                                                                                                  	Time             int           `json:"time"`
                                                                                                                                                                                                                                  	Blocktime        int           `json:"blocktime"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                  type GetReceivedByAccount

                                                                                                                                                                                                                                  type GetReceivedByAccount struct {
                                                                                                                                                                                                                                  	Result int64  `json:"result"`
                                                                                                                                                                                                                                  	Error  Error  `json:"error"`
                                                                                                                                                                                                                                  	ID     string `json:"id"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                  type GetReceivedByAddress

                                                                                                                                                                                                                                  type GetReceivedByAddress struct {
                                                                                                                                                                                                                                  	Result int64  `json:"result"`
                                                                                                                                                                                                                                  	Error  Error  `json:"error"`
                                                                                                                                                                                                                                  	ID     string `json:"id"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                  type GetTransaction

                                                                                                                                                                                                                                  type GetTransaction struct {
                                                                                                                                                                                                                                  	Result struct {
                                                                                                                                                                                                                                  		Amount           float64       `json:"amount"`
                                                                                                                                                                                                                                  		Fee              float64       `json:"fee"`
                                                                                                                                                                                                                                  		Rawconfirmations int           `json:"rawconfirmations"`
                                                                                                                                                                                                                                  		Confirmations    int           `json:"confirmations"`
                                                                                                                                                                                                                                  		Blockhash        string        `json:"blockhash"`
                                                                                                                                                                                                                                  		Blockindex       int           `json:"blockindex"`
                                                                                                                                                                                                                                  		Blocktime        int           `json:"blocktime"`
                                                                                                                                                                                                                                  		Expiryheight     int           `json:"expiryheight"`
                                                                                                                                                                                                                                  		Txid             string        `json:"txid"`
                                                                                                                                                                                                                                  		Walletconflicts  []interface{} `json:"walletconflicts"`
                                                                                                                                                                                                                                  		Time             int           `json:"time"`
                                                                                                                                                                                                                                  		Timereceived     int           `json:"timereceived"`
                                                                                                                                                                                                                                  		Vjoinsplit       []interface{} `json:"vjoinsplit"`
                                                                                                                                                                                                                                  		Details          []struct {
                                                                                                                                                                                                                                  			InvolvesWatchonly bool    `json:"involvesWatchonly"`
                                                                                                                                                                                                                                  			Account           string  `json:"account"`
                                                                                                                                                                                                                                  			Address           string  `json:"address"`
                                                                                                                                                                                                                                  			Category          string  `json:"category"`
                                                                                                                                                                                                                                  			Amount            float64 `json:"amount"`
                                                                                                                                                                                                                                  			Vout              int     `json:"vout"`
                                                                                                                                                                                                                                  			Fee               float64 `json:"fee,omitempty"`
                                                                                                                                                                                                                                  			Size              int     `json:"size"`
                                                                                                                                                                                                                                  		} `json:"details"`
                                                                                                                                                                                                                                  		Hex string `json:"hex"`
                                                                                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                  type GetTxOut

                                                                                                                                                                                                                                  type GetTxOut struct {
                                                                                                                                                                                                                                  	Result struct {
                                                                                                                                                                                                                                  		Bestblock        string  `json:"bestblock"`
                                                                                                                                                                                                                                  		Confirmations    int     `json:"confirmations"`
                                                                                                                                                                                                                                  		Rawconfirmations int     `json:"rawconfirmations"`
                                                                                                                                                                                                                                  		Value            float64 `json:"value"`
                                                                                                                                                                                                                                  		ScriptPubKey     struct {
                                                                                                                                                                                                                                  			Asm       string   `json:"asm"`
                                                                                                                                                                                                                                  			Hex       string   `json:"hex"`
                                                                                                                                                                                                                                  			ReqSigs   int      `json:"reqSigs"`
                                                                                                                                                                                                                                  			Type      string   `json:"type"`
                                                                                                                                                                                                                                  			Addresses []string `json:"addresses"`
                                                                                                                                                                                                                                  		} `json:"scriptPubKey"`
                                                                                                                                                                                                                                  		Version  int  `json:"version"`
                                                                                                                                                                                                                                  		Coinbase bool `json:"coinbase"`
                                                                                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    GetTxOut type

                                                                                                                                                                                                                                    type GetTxOutProof

                                                                                                                                                                                                                                    type GetTxOutProof struct {
                                                                                                                                                                                                                                    	Result string `json:"result"`
                                                                                                                                                                                                                                    	Error  Error  `json:"error"`
                                                                                                                                                                                                                                    	ID     string `json:"id"`
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      GetTxOutProof type

                                                                                                                                                                                                                                      type GetTxOutSetInfo

                                                                                                                                                                                                                                      type GetTxOutSetInfo struct {
                                                                                                                                                                                                                                      	Result struct {
                                                                                                                                                                                                                                      		Height          int     `json:"height"`
                                                                                                                                                                                                                                      		Bestblock       string  `json:"bestblock"`
                                                                                                                                                                                                                                      		Transactions    int     `json:"transactions"`
                                                                                                                                                                                                                                      		Txouts          int     `json:"txouts"`
                                                                                                                                                                                                                                      		BytesSerialized int     `json:"bytes_serialized"`
                                                                                                                                                                                                                                      		HashSerialized  string  `json:"hash_serialized"`
                                                                                                                                                                                                                                      		TotalAmount     float64 `json:"total_amount"`
                                                                                                                                                                                                                                      	} `json:"result"`
                                                                                                                                                                                                                                      	Error Error  `json:"error"`
                                                                                                                                                                                                                                      	ID    string `json:"id"`
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        GetTxOutSetInfo type

                                                                                                                                                                                                                                        type GetUnconfirmedBalance

                                                                                                                                                                                                                                        type GetUnconfirmedBalance struct {
                                                                                                                                                                                                                                        	Result float64 `json:"result"`
                                                                                                                                                                                                                                        	Error  Error   `json:"error"`
                                                                                                                                                                                                                                        	ID     string  `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type GetWalletInfo

                                                                                                                                                                                                                                        type GetWalletInfo struct {
                                                                                                                                                                                                                                        	Result struct {
                                                                                                                                                                                                                                        		Walletversion      int     `json:"walletversion"`
                                                                                                                                                                                                                                        		Balance            float64 `json:"balance"`
                                                                                                                                                                                                                                        		UnconfirmedBalance float64 `json:"unconfirmed_balance"`
                                                                                                                                                                                                                                        		ImmatureBalance    float64 `json:"immature_balance"`
                                                                                                                                                                                                                                        		Txcount            int     `json:"txcount"`
                                                                                                                                                                                                                                        		Keypoololdest      int     `json:"keypoololdest"`
                                                                                                                                                                                                                                        		Keypoolsize        int     `json:"keypoolsize"`
                                                                                                                                                                                                                                        		UnlockedUntil      int     `json:"unlocked_until"`
                                                                                                                                                                                                                                        		Paytxfee           float64 `json:"paytxfee"`
                                                                                                                                                                                                                                        		Seedfp             string  `json:"seedfp"`
                                                                                                                                                                                                                                        	} `json:"result"`
                                                                                                                                                                                                                                        	Error Error  `json:"error"`
                                                                                                                                                                                                                                        	ID    string `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ImportAddress

                                                                                                                                                                                                                                        type ImportAddress struct {
                                                                                                                                                                                                                                        	Result string `json:"result"`
                                                                                                                                                                                                                                        	Error  Error  `json:"error"`
                                                                                                                                                                                                                                        	ID     string `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ImportPrivKey

                                                                                                                                                                                                                                        type ImportPrivKey struct {
                                                                                                                                                                                                                                        	Result string `json:"result"`
                                                                                                                                                                                                                                        	Error  Error  `json:"error"`
                                                                                                                                                                                                                                        	ID     string `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ImportWallet

                                                                                                                                                                                                                                        type ImportWallet struct {
                                                                                                                                                                                                                                        	Result interface{} `json:"result"`
                                                                                                                                                                                                                                        	Error  Error       `json:"error"`
                                                                                                                                                                                                                                        	ID     string      `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type KeyPoolRefill

                                                                                                                                                                                                                                        type KeyPoolRefill struct {
                                                                                                                                                                                                                                        	Result interface{} `json:"result"`
                                                                                                                                                                                                                                        	Error  Error       `json:"error"`
                                                                                                                                                                                                                                        	ID     string      `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ListAccounts

                                                                                                                                                                                                                                        type ListAccounts struct {
                                                                                                                                                                                                                                        	Result map[string]float64 `json:"result"`
                                                                                                                                                                                                                                        	Error  Error              `json:"error"`
                                                                                                                                                                                                                                        	ID     string             `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ListAddressGroupings

                                                                                                                                                                                                                                        type ListAddressGroupings struct {
                                                                                                                                                                                                                                        	Result [][][]interface{} `json:"result"`
                                                                                                                                                                                                                                        	Error  Error             `json:"error"`
                                                                                                                                                                                                                                        	ID     string            `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ListBanned

                                                                                                                                                                                                                                        type ListBanned struct {
                                                                                                                                                                                                                                        	Result []struct {
                                                                                                                                                                                                                                        		Address     string `json:"address"`
                                                                                                                                                                                                                                        		BannedUntil int    `json:"banned_until"`
                                                                                                                                                                                                                                        	} `json:"result"`
                                                                                                                                                                                                                                        	Error Error  `json:"error"`
                                                                                                                                                                                                                                        	ID    string `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ListCurrencies

                                                                                                                                                                                                                                        type ListCurrencies struct {
                                                                                                                                                                                                                                        	Result []struct {
                                                                                                                                                                                                                                        		Currencydefinition struct {
                                                                                                                                                                                                                                        			Name                 string               `json:"name"`
                                                                                                                                                                                                                                        			Version              int                  `json:"version"`
                                                                                                                                                                                                                                        			Options              int                  `json:"options"`
                                                                                                                                                                                                                                        			Parent               string               `json:"parent"`
                                                                                                                                                                                                                                        			Systemid             string               `json:"systemid"`
                                                                                                                                                                                                                                        			Currencyid           string               `json:"currencyid"`
                                                                                                                                                                                                                                        			Notarizationprotocol int                  `json:"notarizationprotocol"`
                                                                                                                                                                                                                                        			Proofprotocol        int                  `json:"proofprotocol"`
                                                                                                                                                                                                                                        			Idregistrationprice  int                  `json:"idregistrationprice"`
                                                                                                                                                                                                                                        			Idreferrallevels     int                  `json:"idreferrallevels"`
                                                                                                                                                                                                                                        			Minnotariesconfirm   int                  `json:"minnotariesconfirm"`
                                                                                                                                                                                                                                        			Billingperiod        int                  `json:"billingperiod"`
                                                                                                                                                                                                                                        			Notarizationreward   int                  `json:"notarizationreward"`
                                                                                                                                                                                                                                        			Startblock           int                  `json:"startblock"`
                                                                                                                                                                                                                                        			Endblock             int                  `json:"endblock"`
                                                                                                                                                                                                                                        			Currencies           []string             `json:"currencies"`
                                                                                                                                                                                                                                        			Weights              []float64            `json:"weights"`
                                                                                                                                                                                                                                        			Conversions          []float64            `json:"conversions"`
                                                                                                                                                                                                                                        			Initialsupply        float64              `json:"initialsupply"`
                                                                                                                                                                                                                                        			Minpreconversion     []float64            `json:"minpreconversion"`
                                                                                                                                                                                                                                        			Preallocation        []map[string]float64 `json:"preallocation"`
                                                                                                                                                                                                                                        			Prelaunchcarveout    float64              `json:"prelaunchcarveout"`
                                                                                                                                                                                                                                        			Initialcontributions []float64            `json:"initialcontributions"`
                                                                                                                                                                                                                                        			Preconversions       []float64            `json:"preconversions"`
                                                                                                                                                                                                                                        			Eras                 []interface{}        `json:"eras"`
                                                                                                                                                                                                                                        		} `json:"currencydefinition,omitempty"`
                                                                                                                                                                                                                                        		Bestheight        int    `json:"bestheight"`
                                                                                                                                                                                                                                        		Besttxid          string `json:"besttxid"`
                                                                                                                                                                                                                                        		Bestcurrencystate struct {
                                                                                                                                                                                                                                        			Flags             int    `json:"flags"`
                                                                                                                                                                                                                                        			Currencyid        string `json:"currencyid"`
                                                                                                                                                                                                                                        			Reservecurrencies []struct {
                                                                                                                                                                                                                                        				Currencyid     string  `json:"currencyid"`
                                                                                                                                                                                                                                        				Weight         float64 `json:"weight"`
                                                                                                                                                                                                                                        				Reserves       float64 `json:"reserves"`
                                                                                                                                                                                                                                        				Priceinreserve float64 `json:"priceinreserve"`
                                                                                                                                                                                                                                        			} `json:"reservecurrencies"`
                                                                                                                                                                                                                                        			Initialsupply        float64               `json:"initialsupply"`
                                                                                                                                                                                                                                        			Emitted              float64               `json:"emitted"`
                                                                                                                                                                                                                                        			Supply               float64               `json:"supply"`
                                                                                                                                                                                                                                        			Currencies           map[string]Currencies `json:"currencies"`
                                                                                                                                                                                                                                        			Nativefees           int                   `json:"nativefees"`
                                                                                                                                                                                                                                        			Nativeconversionfees int                   `json:"nativeconversionfees"`
                                                                                                                                                                                                                                        		} `json:"bestcurrencystate,omitempty"`
                                                                                                                                                                                                                                        	} `json:"result"`
                                                                                                                                                                                                                                        	Error Error  `json:"error"`
                                                                                                                                                                                                                                        	ID    string `json:"id"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          ListCurrencies type

                                                                                                                                                                                                                                          type ListIdentities

                                                                                                                                                                                                                                          type ListIdentities struct {
                                                                                                                                                                                                                                          	Result []struct {
                                                                                                                                                                                                                                          		Identity struct {
                                                                                                                                                                                                                                          			Version           int      `json:"version"`
                                                                                                                                                                                                                                          			Flags             int      `json:"flags"`
                                                                                                                                                                                                                                          			Primaryaddresses  []string `json:"primaryaddresses"`
                                                                                                                                                                                                                                          			Minimumsignatures int      `json:"minimumsignatures"`
                                                                                                                                                                                                                                          			Identityaddress   string   `json:"identityaddress"`
                                                                                                                                                                                                                                          			Parent            string   `json:"parent"`
                                                                                                                                                                                                                                          			Name              string   `json:"name"`
                                                                                                                                                                                                                                          			Contentmap        struct {
                                                                                                                                                                                                                                          			} `json:"contentmap"`
                                                                                                                                                                                                                                          			Revocationauthority string `json:"revocationauthority"`
                                                                                                                                                                                                                                          			Recoveryauthority   string `json:"recoveryauthority"`
                                                                                                                                                                                                                                          			Privateaddress      string `json:"privateaddress"`
                                                                                                                                                                                                                                          			Timelock            int    `json:"timelock"`
                                                                                                                                                                                                                                          		} `json:"identity"`
                                                                                                                                                                                                                                          		Blockheight int    `json:"blockheight"`
                                                                                                                                                                                                                                          		Txid        string `json:"txid"`
                                                                                                                                                                                                                                          		Status      string `json:"status"`
                                                                                                                                                                                                                                          		Canspendfor bool   `json:"canspendfor"`
                                                                                                                                                                                                                                          		Cansignfor  bool   `json:"cansignfor"`
                                                                                                                                                                                                                                          	} `json:"result"`
                                                                                                                                                                                                                                          	Error Error  `json:"error"`
                                                                                                                                                                                                                                          	ID    string `json:"id"`
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            ListIdentities struct type to render result for ListIdentities func

                                                                                                                                                                                                                                            type ListLockUnspent

                                                                                                                                                                                                                                            type ListLockUnspent struct {
                                                                                                                                                                                                                                            	Result []struct {
                                                                                                                                                                                                                                            		Txid string `json:"txid"`
                                                                                                                                                                                                                                            		Vout int    `json:"vout"`
                                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            type ListReceivedByAddress

                                                                                                                                                                                                                                            type ListReceivedByAddress struct {
                                                                                                                                                                                                                                            	Result []struct {
                                                                                                                                                                                                                                            		Address          string        `json:"address"`
                                                                                                                                                                                                                                            		Account          string        `json:"account"`
                                                                                                                                                                                                                                            		Amount           float64       `json:"amount"`
                                                                                                                                                                                                                                            		Rawconfirmations int           `json:"rawconfirmations"`
                                                                                                                                                                                                                                            		Confirmations    int           `json:"confirmations"`
                                                                                                                                                                                                                                            		Txids            []interface{} `json:"txids"`
                                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            type ListSinceBlock

                                                                                                                                                                                                                                            type ListSinceBlock struct {
                                                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                                                            		Transactions []struct {
                                                                                                                                                                                                                                            			Account         string        `json:"account"`
                                                                                                                                                                                                                                            			Address         string        `json:"address"`
                                                                                                                                                                                                                                            			Category        string        `json:"category"`
                                                                                                                                                                                                                                            			Amount          float64       `json:"amount"`
                                                                                                                                                                                                                                            			Vout            int           `json:"vout"`
                                                                                                                                                                                                                                            			Confirmations   int           `json:"confirmations"`
                                                                                                                                                                                                                                            			Generated       bool          `json:"generated"`
                                                                                                                                                                                                                                            			Blockhash       string        `json:"blockhash"`
                                                                                                                                                                                                                                            			Blockindex      int           `json:"blockindex"`
                                                                                                                                                                                                                                            			Blocktime       int           `json:"blocktime"`
                                                                                                                                                                                                                                            			Expiryheight    int           `json:"expiryheight"`
                                                                                                                                                                                                                                            			Txid            string        `json:"txid"`
                                                                                                                                                                                                                                            			Walletconflicts []interface{} `json:"walletconflicts"`
                                                                                                                                                                                                                                            			Time            int           `json:"time"`
                                                                                                                                                                                                                                            			Timereceived    int           `json:"timereceived"`
                                                                                                                                                                                                                                            			Vjoinsplit      []interface{} `json:"vjoinsplit"`
                                                                                                                                                                                                                                            			Size            int           `json:"size"`
                                                                                                                                                                                                                                            		} `json:"transactions"`
                                                                                                                                                                                                                                            		Lastblock string `json:"lastblock"`
                                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            type ListTransactions

                                                                                                                                                                                                                                            type ListTransactions struct {
                                                                                                                                                                                                                                            	Result []struct {
                                                                                                                                                                                                                                            		InvolvesWatchonly bool          `json:"involvesWatchonly"`
                                                                                                                                                                                                                                            		Account           string        `json:"account"`
                                                                                                                                                                                                                                            		Address           string        `json:"address"`
                                                                                                                                                                                                                                            		Category          string        `json:"category"`
                                                                                                                                                                                                                                            		Amount            float64       `json:"amount"`
                                                                                                                                                                                                                                            		Vout              int           `json:"vout"`
                                                                                                                                                                                                                                            		Fee               float64       `json:"fee,omitempty"`
                                                                                                                                                                                                                                            		Rawconfirmations  int           `json:"rawconfirmations"`
                                                                                                                                                                                                                                            		Confirmations     int           `json:"confirmations"`
                                                                                                                                                                                                                                            		Blockhash         string        `json:"blockhash"`
                                                                                                                                                                                                                                            		Blockindex        int           `json:"blockindex"`
                                                                                                                                                                                                                                            		Blocktime         int           `json:"blocktime"`
                                                                                                                                                                                                                                            		Expiryheight      int           `json:"expiryheight"`
                                                                                                                                                                                                                                            		Txid              string        `json:"txid"`
                                                                                                                                                                                                                                            		Walletconflicts   []interface{} `json:"walletconflicts"`
                                                                                                                                                                                                                                            		Time              int           `json:"time"`
                                                                                                                                                                                                                                            		Timereceived      int           `json:"timereceived"`
                                                                                                                                                                                                                                            		Vjoinsplit        []interface{} `json:"vjoinsplit"`
                                                                                                                                                                                                                                            		Size              int           `json:"size"`
                                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            type ListUnspent

                                                                                                                                                                                                                                            type ListUnspent struct {
                                                                                                                                                                                                                                            	Result []struct {
                                                                                                                                                                                                                                            		Txid          string  `json:"txid"`
                                                                                                                                                                                                                                            		Vout          int     `json:"vout"`
                                                                                                                                                                                                                                            		Generated     bool    `json:"generated"`
                                                                                                                                                                                                                                            		Address       string  `json:"address"`
                                                                                                                                                                                                                                            		ScriptPubKey  string  `json:"scriptPubKey"`
                                                                                                                                                                                                                                            		Amount        float64 `json:"amount"`
                                                                                                                                                                                                                                            		Interest      float64 `json:"interest"`
                                                                                                                                                                                                                                            		Confirmations int     `json:"confirmations"`
                                                                                                                                                                                                                                            		Spendable     bool    `json:"spendable"`
                                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            type LockUnspent

                                                                                                                                                                                                                                            type LockUnspent struct {
                                                                                                                                                                                                                                            	Result bool   `json:"result"`
                                                                                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            type MinerIDs

                                                                                                                                                                                                                                            type MinerIDs struct {
                                                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                                                            		Mined []struct {
                                                                                                                                                                                                                                            			Notaryid   int    `json:"notaryid,omitempty"`
                                                                                                                                                                                                                                            			KMDaddress string `json:"KMDaddress,omitempty"`
                                                                                                                                                                                                                                            			Pubkey     string `json:"pubkey"`
                                                                                                                                                                                                                                            			Blocks     int    `json:"blocks"`
                                                                                                                                                                                                                                            		} `json:"mined"`
                                                                                                                                                                                                                                            		Numnotaries int `json:"numnotaries"`
                                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              MinerIDs type

                                                                                                                                                                                                                                              type Notaries

                                                                                                                                                                                                                                              type Notaries struct {
                                                                                                                                                                                                                                              	Result struct {
                                                                                                                                                                                                                                              		Notaries []struct {
                                                                                                                                                                                                                                              			Pubkey     string `json:"pubkey"`
                                                                                                                                                                                                                                              			BTCaddress string `json:"BTCaddress"`
                                                                                                                                                                                                                                              			KMDaddress string `json:"KMDaddress"`
                                                                                                                                                                                                                                              		} `json:"notaries"`
                                                                                                                                                                                                                                              		Numnotaries int `json:"numnotaries"`
                                                                                                                                                                                                                                              		Height      int `json:"height"`
                                                                                                                                                                                                                                              		Timestamp   int `json:"timestamp"`
                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                Notaries type

                                                                                                                                                                                                                                                type Ping

                                                                                                                                                                                                                                                type Ping struct {
                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                type PrioritiseTransaction

                                                                                                                                                                                                                                                type PrioritiseTransaction struct {
                                                                                                                                                                                                                                                	Result bool   `json:"result"`
                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                type RGBailout

                                                                                                                                                                                                                                                type RGBailout struct {
                                                                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                                                                		Name        string `json:"name"`
                                                                                                                                                                                                                                                		Method      string `json:"method"`
                                                                                                                                                                                                                                                		Myrogueaddr string `json:"myrogueaddr"`
                                                                                                                                                                                                                                                		Gametxid    string `json:"gametxid"`
                                                                                                                                                                                                                                                		Hex         string `json:"hex"`
                                                                                                                                                                                                                                                		Txid        string `json:"txid"`
                                                                                                                                                                                                                                                		Result      string `json:"result"`
                                                                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  RGBailout type

                                                                                                                                                                                                                                                  type RGGameInfo

                                                                                                                                                                                                                                                  type RGGameInfo struct {
                                                                                                                                                                                                                                                  	Result struct {
                                                                                                                                                                                                                                                  		Name       string  `json:"name"`
                                                                                                                                                                                                                                                  		Method     string  `json:"method"`
                                                                                                                                                                                                                                                  		Gametxid   string  `json:"gametxid"`
                                                                                                                                                                                                                                                  		Result     string  `json:"result"`
                                                                                                                                                                                                                                                  		Gameheight int     `json:"gameheight"`
                                                                                                                                                                                                                                                  		Height     int     `json:"height"`
                                                                                                                                                                                                                                                  		Start      int     `json:"start"`
                                                                                                                                                                                                                                                  		Starthash  string  `json:"starthash"`
                                                                                                                                                                                                                                                  		Seed       int64   `json:"seed"`
                                                                                                                                                                                                                                                  		Run        string  `json:"run"`
                                                                                                                                                                                                                                                  		Alive      int     `json:"alive"`
                                                                                                                                                                                                                                                  		Numplayers int     `json:"numplayers"`
                                                                                                                                                                                                                                                  		Maxplayers int     `json:"maxplayers"`
                                                                                                                                                                                                                                                  		Buyin      float64 `json:"buyin"`
                                                                                                                                                                                                                                                  		Players    []struct {
                                                                                                                                                                                                                                                  			Slot       int     `json:"slot"`
                                                                                                                                                                                                                                                  			Status     string  `json:"status"`
                                                                                                                                                                                                                                                  			Baton      string  `json:"baton"`
                                                                                                                                                                                                                                                  			Tokenid    string  `json:"tokenid"`
                                                                                                                                                                                                                                                  			Batonaddr  string  `json:"batonaddr"`
                                                                                                                                                                                                                                                  			Ismine     bool    `json:"ismine"`
                                                                                                                                                                                                                                                  			Batonvout  int     `json:"batonvout"`
                                                                                                                                                                                                                                                  			Batonvalue float64 `json:"batonvalue"`
                                                                                                                                                                                                                                                  			Batonht    int     `json:"batonht"`
                                                                                                                                                                                                                                                  		} `json:"players"`
                                                                                                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    RGGameInfo type

                                                                                                                                                                                                                                                    type RGGames

                                                                                                                                                                                                                                                    type RGGames struct {
                                                                                                                                                                                                                                                    	Result struct {
                                                                                                                                                                                                                                                    		Name      string   `json:"name"`
                                                                                                                                                                                                                                                    		Method    string   `json:"method"`
                                                                                                                                                                                                                                                    		Pastgames []string `json:"pastgames"`
                                                                                                                                                                                                                                                    		Games     []string `json:"games"`
                                                                                                                                                                                                                                                    		Numgames  int      `json:"numgames"`
                                                                                                                                                                                                                                                    	} `json:"result"`
                                                                                                                                                                                                                                                    	Error Error  `json:"error"`
                                                                                                                                                                                                                                                    	ID    string `json:"id"`
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      RGGames type

                                                                                                                                                                                                                                                      type RGHighLander

                                                                                                                                                                                                                                                      type RGHighLander struct {
                                                                                                                                                                                                                                                      	Result struct {
                                                                                                                                                                                                                                                      		Name        string `json:"name"`
                                                                                                                                                                                                                                                      		Method      string `json:"method"`
                                                                                                                                                                                                                                                      		Myrogueaddr string `json:"myrogueaddr"`
                                                                                                                                                                                                                                                      		Gametxid    string `json:"gametxid"`
                                                                                                                                                                                                                                                      		Hex         string `json:"hex"`
                                                                                                                                                                                                                                                      		Txid        string `json:"txid"`
                                                                                                                                                                                                                                                      		Result      string `json:"result"`
                                                                                                                                                                                                                                                      	} `json:"result"`
                                                                                                                                                                                                                                                      	Error Error  `json:"error"`
                                                                                                                                                                                                                                                      	ID    string `json:"id"`
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        RGHighLander type

                                                                                                                                                                                                                                                        type RGNewGame

                                                                                                                                                                                                                                                        type RGNewGame struct {
                                                                                                                                                                                                                                                        	Result struct {
                                                                                                                                                                                                                                                        		Name       string  `json:"name"`
                                                                                                                                                                                                                                                        		Method     string  `json:"method"`
                                                                                                                                                                                                                                                        		Maxplayers int     `json:"maxplayers"`
                                                                                                                                                                                                                                                        		Buyin      float64 `json:"buyin"`
                                                                                                                                                                                                                                                        		Type       string  `json:"type"`
                                                                                                                                                                                                                                                        		Hex        string  `json:"hex"`
                                                                                                                                                                                                                                                        		Txid       string  `json:"txid"`
                                                                                                                                                                                                                                                        		Result     string  `json:"result"`
                                                                                                                                                                                                                                                        	} `json:"result"`
                                                                                                                                                                                                                                                        	Error Error  `json:"error"`
                                                                                                                                                                                                                                                        	ID    string `json:"id"`
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          RGNewGame type

                                                                                                                                                                                                                                                          type RGPending

                                                                                                                                                                                                                                                          type RGPending struct {
                                                                                                                                                                                                                                                          	Result struct {
                                                                                                                                                                                                                                                          		Result     string   `json:"result"`
                                                                                                                                                                                                                                                          		Name       string   `json:"name"`
                                                                                                                                                                                                                                                          		Method     string   `json:"method"`
                                                                                                                                                                                                                                                          		Pending    []string `json:"pending"`
                                                                                                                                                                                                                                                          		Numpending int      `json:"numpending"`
                                                                                                                                                                                                                                                          	} `json:"result"`
                                                                                                                                                                                                                                                          	Error Error  `json:"error"`
                                                                                                                                                                                                                                                          	ID    string `json:"id"`
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            RGPending type

                                                                                                                                                                                                                                                            type RGPlayerInfo

                                                                                                                                                                                                                                                            type RGPlayerInfo struct {
                                                                                                                                                                                                                                                            	Result struct {
                                                                                                                                                                                                                                                            		Result string `json:"result"`
                                                                                                                                                                                                                                                            		Name   string `json:"name"`
                                                                                                                                                                                                                                                            		Method string `json:"method"`
                                                                                                                                                                                                                                                            		Player struct {
                                                                                                                                                                                                                                                            			Playertxid   string   `json:"playertxid"`
                                                                                                                                                                                                                                                            			Tokenid      string   `json:"tokenid"`
                                                                                                                                                                                                                                                            			Data         string   `json:"data"`
                                                                                                                                                                                                                                                            			Pack         []string `json:"pack"`
                                                                                                                                                                                                                                                            			Packsize     int      `json:"packsize"`
                                                                                                                                                                                                                                                            			Hitpoints    int      `json:"hitpoints"`
                                                                                                                                                                                                                                                            			Strength     int      `json:"strength"`
                                                                                                                                                                                                                                                            			Level        int      `json:"level"`
                                                                                                                                                                                                                                                            			Experience   int      `json:"experience"`
                                                                                                                                                                                                                                                            			Dungeonlevel int      `json:"dungeonlevel"`
                                                                                                                                                                                                                                                            			Chain        string   `json:"chain"`
                                                                                                                                                                                                                                                            			Pname        string   `json:"pname"`
                                                                                                                                                                                                                                                            		} `json:"player"`
                                                                                                                                                                                                                                                            	} `json:"result"`
                                                                                                                                                                                                                                                            	Error Error  `json:"error"`
                                                                                                                                                                                                                                                            	ID    string `json:"id"`
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              RGPlayerInfo type

                                                                                                                                                                                                                                                              type RGPlayers

                                                                                                                                                                                                                                                              type RGPlayers struct {
                                                                                                                                                                                                                                                              	Result struct {
                                                                                                                                                                                                                                                              		Name          string   `json:"name"`
                                                                                                                                                                                                                                                              		Method        string   `json:"method"`
                                                                                                                                                                                                                                                              		Playerdata    []string `json:"playerdata"`
                                                                                                                                                                                                                                                              		Numplayerdata int      `json:"numplayerdata"`
                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                RGPlayers type

                                                                                                                                                                                                                                                                type RGRegister

                                                                                                                                                                                                                                                                type RGRegister struct {
                                                                                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                                                                                		Name       string  `json:"name"`
                                                                                                                                                                                                                                                                		Method     string  `json:"method"`
                                                                                                                                                                                                                                                                		Maxplayers int     `json:"maxplayers"`
                                                                                                                                                                                                                                                                		Buyin      float64 `json:"buyin"`
                                                                                                                                                                                                                                                                		Type       string  `json:"type"`
                                                                                                                                                                                                                                                                		Hex        string  `json:"hex"`
                                                                                                                                                                                                                                                                		Txid       string  `json:"txid,omitempty"`
                                                                                                                                                                                                                                                                		Result     string  `json:"result,omitempty"`
                                                                                                                                                                                                                                                                		Status     string  `json:"status,omitempty"`
                                                                                                                                                                                                                                                                		Error      string  `json:"error,omitempty"`
                                                                                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  RGRegister type

                                                                                                                                                                                                                                                                  type RGSetName

                                                                                                                                                                                                                                                                  type RGSetName struct {
                                                                                                                                                                                                                                                                  	Result struct {
                                                                                                                                                                                                                                                                  		Name   string `json:"name"`
                                                                                                                                                                                                                                                                  		Method string `json:"method"`
                                                                                                                                                                                                                                                                  		Result string `json:"result"`
                                                                                                                                                                                                                                                                  	} `json:"result"`
                                                                                                                                                                                                                                                                  	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                  	ID    string `json:"id"`
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    RGSetName type

                                                                                                                                                                                                                                                                    type RawMempoolTrue

                                                                                                                                                                                                                                                                    type RawMempoolTrue struct {
                                                                                                                                                                                                                                                                    	Size             int           `json:"size"`
                                                                                                                                                                                                                                                                    	Fee              float64       `json:"fee"`
                                                                                                                                                                                                                                                                    	Time             int           `json:"time"`
                                                                                                                                                                                                                                                                    	Height           int           `json:"height"`
                                                                                                                                                                                                                                                                    	Startingpriority float64       `json:"startingpriority"`
                                                                                                                                                                                                                                                                    	Currentpriority  float64       `json:"currentpriority"`
                                                                                                                                                                                                                                                                    	Depends          []interface{} `json:"depends"`
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      RawMempoolTrue type

                                                                                                                                                                                                                                                                      type RegisterIdentity

                                                                                                                                                                                                                                                                      type RegisterIdentity struct {
                                                                                                                                                                                                                                                                      	Result string `json:"result"`
                                                                                                                                                                                                                                                                      	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                      	ID     string `json:"id"`
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        RegisterIdentity type

                                                                                                                                                                                                                                                                        type RegisterIdentityData

                                                                                                                                                                                                                                                                        type RegisterIdentityData struct {
                                                                                                                                                                                                                                                                        	Txid            string `json:"txid"`
                                                                                                                                                                                                                                                                        	Namereservation struct {
                                                                                                                                                                                                                                                                        		Name     string `json:"name"`
                                                                                                                                                                                                                                                                        		Salt     string `json:"salt"`
                                                                                                                                                                                                                                                                        		Referral string `json:"referral"`
                                                                                                                                                                                                                                                                        		Parent   string `json:"parent"`
                                                                                                                                                                                                                                                                        		Nameid   string `json:"nameid"`
                                                                                                                                                                                                                                                                        	} `json:"namereservation"`
                                                                                                                                                                                                                                                                        	Identity struct {
                                                                                                                                                                                                                                                                        		Name                string   `json:"name"`
                                                                                                                                                                                                                                                                        		Primaryaddresses    []string `json:"primaryaddresses"`
                                                                                                                                                                                                                                                                        		Minimumsignatures   int      `json:"minimumsignatures"`
                                                                                                                                                                                                                                                                        		Revocationauthority string   `json:"revocationauthority"`
                                                                                                                                                                                                                                                                        		Recoveryauthority   string   `json:"recoveryauthority"`
                                                                                                                                                                                                                                                                        		Privateaddress      string   `json:"privateaddress"`
                                                                                                                                                                                                                                                                        	} `json:"identity"`
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          RegisterIdentityData holds the JSON data supplied for registering VerusID

                                                                                                                                                                                                                                                                          type RegisterNameCommitment

                                                                                                                                                                                                                                                                          type RegisterNameCommitment struct {
                                                                                                                                                                                                                                                                          	Result struct {
                                                                                                                                                                                                                                                                          		Txid            string `json:"txid"`
                                                                                                                                                                                                                                                                          		Namereservation struct {
                                                                                                                                                                                                                                                                          			Name     string `json:"name"`
                                                                                                                                                                                                                                                                          			Salt     string `json:"salt"`
                                                                                                                                                                                                                                                                          			Referral string `json:"referral"`
                                                                                                                                                                                                                                                                          			Parent   string `json:"parent"`
                                                                                                                                                                                                                                                                          			Nameid   string `json:"nameid"`
                                                                                                                                                                                                                                                                          		} `json:"namereservation"`
                                                                                                                                                                                                                                                                          	} `json:"result"`
                                                                                                                                                                                                                                                                          	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                          	ID    string `json:"id"`
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            RegisterNameCommitment type

                                                                                                                                                                                                                                                                            type SendCurrency

                                                                                                                                                                                                                                                                            type SendCurrency struct {
                                                                                                                                                                                                                                                                            	Result string `json:"result"`
                                                                                                                                                                                                                                                                            	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                            	ID     string `json:"id"`
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              SendCurrency type

                                                                                                                                                                                                                                                                              type SendCurrencyInput

                                                                                                                                                                                                                                                                              type SendCurrencyInput struct {
                                                                                                                                                                                                                                                                              	Address     string  `json:"address"`
                                                                                                                                                                                                                                                                              	Amount      float64 `json:"amount"`
                                                                                                                                                                                                                                                                              	Convertto   string  `json:"convertto,omitempty"`
                                                                                                                                                                                                                                                                              	Via         string  `json:"via,omitempty"`
                                                                                                                                                                                                                                                                              	Currency    string  `json:"currency,omitempty"`
                                                                                                                                                                                                                                                                              	Refundto    string  `json:"refundto,omitempty"`
                                                                                                                                                                                                                                                                              	Memo        string  `json:"memo,omitempty"`
                                                                                                                                                                                                                                                                              	Preconvert  bool    `json:"preconvert,omitempty"`
                                                                                                                                                                                                                                                                              	Subtractfee bool    `json:"subtractfee,omitempty"`
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                SendCurrencyInput to generate JSON output which can be used as data input for SendCurrency API

                                                                                                                                                                                                                                                                                type SendFrom

                                                                                                                                                                                                                                                                                type SendFrom struct {
                                                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SendMany

                                                                                                                                                                                                                                                                                type SendMany struct {
                                                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SendRawTransaction

                                                                                                                                                                                                                                                                                type SendRawTransaction struct {
                                                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SendToAddress

                                                                                                                                                                                                                                                                                type SendToAddress struct {
                                                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SetBan

                                                                                                                                                                                                                                                                                type SetBan struct {
                                                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SetPubKey

                                                                                                                                                                                                                                                                                type SetPubKey struct {
                                                                                                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                                                                                                		Pubkey   string `json:"pubkey"`
                                                                                                                                                                                                                                                                                		Ismine   bool   `json:"ismine"`
                                                                                                                                                                                                                                                                                		RAddress string `json:"R-address"`
                                                                                                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SetTxFee

                                                                                                                                                                                                                                                                                type SetTxFee struct {
                                                                                                                                                                                                                                                                                	Result bool   `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SignMessage

                                                                                                                                                                                                                                                                                type SignMessage struct {
                                                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type SignRawTransaction

                                                                                                                                                                                                                                                                                type SignRawTransaction struct {
                                                                                                                                                                                                                                                                                	Result struct {
                                                                                                                                                                                                                                                                                		Hex      string `json:"hex"`
                                                                                                                                                                                                                                                                                		Complete bool   `json:"complete"`
                                                                                                                                                                                                                                                                                		Errors   []struct {
                                                                                                                                                                                                                                                                                			Txid      string `json:"txid"`
                                                                                                                                                                                                                                                                                			Vout      int    `json:"vout"`
                                                                                                                                                                                                                                                                                			ScriptSig string `json:"scriptSig"`
                                                                                                                                                                                                                                                                                			Sequence  int64  `json:"sequence"`
                                                                                                                                                                                                                                                                                			Error     string `json:"error"`
                                                                                                                                                                                                                                                                                		} `json:"errors"`
                                                                                                                                                                                                                                                                                	} `json:"result"`
                                                                                                                                                                                                                                                                                	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                type Stop

                                                                                                                                                                                                                                                                                type Stop struct {
                                                                                                                                                                                                                                                                                	Result string `json:"result"`
                                                                                                                                                                                                                                                                                	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                  Stop struct type to store output of chain stop command

                                                                                                                                                                                                                                                                                  type SubmitBlock

                                                                                                                                                                                                                                                                                  type SubmitBlock struct {
                                                                                                                                                                                                                                                                                  	Result bool   `json:"result"`
                                                                                                                                                                                                                                                                                  	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                  	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                  type UpdateIdentity

                                                                                                                                                                                                                                                                                  type UpdateIdentity struct {
                                                                                                                                                                                                                                                                                  	Result string `json:"result"`
                                                                                                                                                                                                                                                                                  	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                  	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    UpdateIdentity type

                                                                                                                                                                                                                                                                                    type UpdateIdentityData

                                                                                                                                                                                                                                                                                    type UpdateIdentityData struct {
                                                                                                                                                                                                                                                                                    	Parent              string                 `json:"parent"`
                                                                                                                                                                                                                                                                                    	Name                string                 `json:"name"`
                                                                                                                                                                                                                                                                                    	Flags               int                    `json:"flags"`
                                                                                                                                                                                                                                                                                    	Timelock            int                    `json:"timelock,omitempty"`
                                                                                                                                                                                                                                                                                    	Primaryaddresses    []string               `json:"primaryaddresses"`
                                                                                                                                                                                                                                                                                    	Minimumsignatures   int                    `json:"minimumsignatures"`
                                                                                                                                                                                                                                                                                    	Contentmap          map[string]interface{} `json:"contentmap"`
                                                                                                                                                                                                                                                                                    	Revocationauthority string                 `json:"revocationauthority"`
                                                                                                                                                                                                                                                                                    	Recoveryauthority   string                 `json:"recoveryauthority"`
                                                                                                                                                                                                                                                                                    	Privateaddress      string                 `json:"privateaddress"`
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      UpdateIdentityData type

                                                                                                                                                                                                                                                                                      type ValidateAddress

                                                                                                                                                                                                                                                                                      type ValidateAddress struct {
                                                                                                                                                                                                                                                                                      	Result struct {
                                                                                                                                                                                                                                                                                      		Isvalid      bool   `json:"isvalid"`
                                                                                                                                                                                                                                                                                      		Address      string `json:"address"`
                                                                                                                                                                                                                                                                                      		ScriptPubKey string `json:"scriptPubKey"`
                                                                                                                                                                                                                                                                                      		Segid        int    `json:"segid"`
                                                                                                                                                                                                                                                                                      		Ismine       bool   `json:"ismine"`
                                                                                                                                                                                                                                                                                      		Iswatchonly  bool   `json:"iswatchonly"`
                                                                                                                                                                                                                                                                                      		Isscript     bool   `json:"isscript"`
                                                                                                                                                                                                                                                                                      		Pubkey       string `json:"pubkey"`
                                                                                                                                                                                                                                                                                      		Iscompressed bool   `json:"iscompressed"`
                                                                                                                                                                                                                                                                                      		Account      string `json:"account"`
                                                                                                                                                                                                                                                                                      	} `json:"result"`
                                                                                                                                                                                                                                                                                      	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                      	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        ValidateAddress struct type to store validate address API output

                                                                                                                                                                                                                                                                                        type VerifyChain

                                                                                                                                                                                                                                                                                        type VerifyChain struct {
                                                                                                                                                                                                                                                                                        	Result bool   `json:"result"`
                                                                                                                                                                                                                                                                                        	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                        	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          VerifyChain type

                                                                                                                                                                                                                                                                                          type VerifyMessage

                                                                                                                                                                                                                                                                                          type VerifyMessage struct {
                                                                                                                                                                                                                                                                                          	Result bool   `json:"result"`
                                                                                                                                                                                                                                                                                          	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                          	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            VerifyMessage type

                                                                                                                                                                                                                                                                                            type VerifyTxOutProof

                                                                                                                                                                                                                                                                                            type VerifyTxOutProof struct {
                                                                                                                                                                                                                                                                                            	Result []string `json:"result"`
                                                                                                                                                                                                                                                                                            	Error  Error    `json:"error"`
                                                                                                                                                                                                                                                                                            	ID     string   `json:"id"`
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              VerifyTxOutProof type

                                                                                                                                                                                                                                                                                              type WalletLock

                                                                                                                                                                                                                                                                                              type WalletLock struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type WalletPassPhrase

                                                                                                                                                                                                                                                                                              type WalletPassPhrase struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type WalletPassPhrasechangeChange

                                                                                                                                                                                                                                                                                              type WalletPassPhrasechangeChange struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZExportKey

                                                                                                                                                                                                                                                                                              type ZExportKey struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZExportViewingKey

                                                                                                                                                                                                                                                                                              type ZExportViewingKey struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZExportWallet

                                                                                                                                                                                                                                                                                              type ZExportWallet struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZGetBalance

                                                                                                                                                                                                                                                                                              type ZGetBalance struct {
                                                                                                                                                                                                                                                                                              	Result float64 `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error   `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string  `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZGetNewAddress

                                                                                                                                                                                                                                                                                              type ZGetNewAddress struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZGetOperationResult

                                                                                                                                                                                                                                                                                              type ZGetOperationResult struct {
                                                                                                                                                                                                                                                                                              	Result []struct {
                                                                                                                                                                                                                                                                                              		ID           string `json:"id"`
                                                                                                                                                                                                                                                                                              		Status       string `json:"status"`
                                                                                                                                                                                                                                                                                              		CreationTime int    `json:"creation_time"`
                                                                                                                                                                                                                                                                                              		Result       struct {
                                                                                                                                                                                                                                                                                              			Txid string `json:"txid"`
                                                                                                                                                                                                                                                                                              		} `json:"result"`
                                                                                                                                                                                                                                                                                              		ExecutionSecs float64 `json:"execution_secs"`
                                                                                                                                                                                                                                                                                              		Method        string  `json:"method"`
                                                                                                                                                                                                                                                                                              		Params        struct {
                                                                                                                                                                                                                                                                                              			Fromaddress string `json:"fromaddress"`
                                                                                                                                                                                                                                                                                              			Amounts     []struct {
                                                                                                                                                                                                                                                                                              				Address string  `json:"address"`
                                                                                                                                                                                                                                                                                              				Amount  float64 `json:"amount"`
                                                                                                                                                                                                                                                                                              			} `json:"amounts"`
                                                                                                                                                                                                                                                                                              			Minconf int     `json:"minconf"`
                                                                                                                                                                                                                                                                                              			Fee     float64 `json:"fee"`
                                                                                                                                                                                                                                                                                              		} `json:"params"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZGetOperationStatus

                                                                                                                                                                                                                                                                                              type ZGetOperationStatus struct {
                                                                                                                                                                                                                                                                                              	Result []struct {
                                                                                                                                                                                                                                                                                              		ID           string `json:"id"`
                                                                                                                                                                                                                                                                                              		Status       string `json:"status"`
                                                                                                                                                                                                                                                                                              		CreationTime int    `json:"creation_time"`
                                                                                                                                                                                                                                                                                              		Result       struct {
                                                                                                                                                                                                                                                                                              			Txid string `json:"txid"`
                                                                                                                                                                                                                                                                                              		} `json:"result"`
                                                                                                                                                                                                                                                                                              		ExecutionSecs float64 `json:"execution_secs"`
                                                                                                                                                                                                                                                                                              		Method        string  `json:"method"`
                                                                                                                                                                                                                                                                                              		Params        struct {
                                                                                                                                                                                                                                                                                              			Fromaddress string `json:"fromaddress"`
                                                                                                                                                                                                                                                                                              			Amounts     []struct {
                                                                                                                                                                                                                                                                                              				Address string  `json:"address"`
                                                                                                                                                                                                                                                                                              				Amount  float64 `json:"amount"`
                                                                                                                                                                                                                                                                                              			} `json:"amounts"`
                                                                                                                                                                                                                                                                                              			Minconf int     `json:"minconf"`
                                                                                                                                                                                                                                                                                              			Fee     float64 `json:"fee"`
                                                                                                                                                                                                                                                                                              		} `json:"params"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZGetTotalBalance

                                                                                                                                                                                                                                                                                              type ZGetTotalBalance struct {
                                                                                                                                                                                                                                                                                              	Result struct {
                                                                                                                                                                                                                                                                                              		Transparent float64 `json:"transparent"`
                                                                                                                                                                                                                                                                                              		Interest    float64 `json:"interest"`
                                                                                                                                                                                                                                                                                              		Private     float64 `json:"private"`
                                                                                                                                                                                                                                                                                              		Total       float64 `json:"total"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZImportKey

                                                                                                                                                                                                                                                                                              type ZImportKey struct {
                                                                                                                                                                                                                                                                                              	Result interface{} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error       `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string      `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZImportViewingKey

                                                                                                                                                                                                                                                                                              type ZImportViewingKey struct {
                                                                                                                                                                                                                                                                                              	Result interface{} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error       `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string      `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZImportWallet

                                                                                                                                                                                                                                                                                              type ZImportWallet struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZListAddresses

                                                                                                                                                                                                                                                                                              type ZListAddresses struct {
                                                                                                                                                                                                                                                                                              	Result []string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error    `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string   `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZListOperationIDs

                                                                                                                                                                                                                                                                                              type ZListOperationIDs struct {
                                                                                                                                                                                                                                                                                              	Result []string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error    `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string   `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZListReceivedByAddress

                                                                                                                                                                                                                                                                                              type ZListReceivedByAddress struct {
                                                                                                                                                                                                                                                                                              	Result []struct {
                                                                                                                                                                                                                                                                                              		Txid   string  `json:"txid"`
                                                                                                                                                                                                                                                                                              		Amount float64 `json:"amount"`
                                                                                                                                                                                                                                                                                              		Memo   string  `json:"memo"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZListUnspent

                                                                                                                                                                                                                                                                                              type ZListUnspent struct {
                                                                                                                                                                                                                                                                                              	Result []struct {
                                                                                                                                                                                                                                                                                              		Txid          string  `json:"txid"`
                                                                                                                                                                                                                                                                                              		Jsindex       int     `json:"jsindex"`
                                                                                                                                                                                                                                                                                              		Jsoutindex    int     `json:"jsoutindex"`
                                                                                                                                                                                                                                                                                              		Outindex      int     `json:"outindex"`
                                                                                                                                                                                                                                                                                              		Confirmations int     `json:"confirmations"`
                                                                                                                                                                                                                                                                                              		Spendable     bool    `json:"spendable"`
                                                                                                                                                                                                                                                                                              		Address       string  `json:"address"`
                                                                                                                                                                                                                                                                                              		Amount        float64 `json:"amount"`
                                                                                                                                                                                                                                                                                              		Memo          string  `json:"memo"`
                                                                                                                                                                                                                                                                                              		Change        bool    `json:"change"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZMergeToAddress

                                                                                                                                                                                                                                                                                              type ZMergeToAddress struct {
                                                                                                                                                                                                                                                                                              	Result struct {
                                                                                                                                                                                                                                                                                              		RemainingUTXOs            int     `json:"remainingUTXOs"`
                                                                                                                                                                                                                                                                                              		RemainingTransparentValue float64 `json:"remainingTransparentValue"`
                                                                                                                                                                                                                                                                                              		RemainingNotes            int     `json:"remainingNotes"`
                                                                                                                                                                                                                                                                                              		RemainingShieldedValue    float64 `json:"remainingShieldedValue"`
                                                                                                                                                                                                                                                                                              		MergingUTXOs              int     `json:"mergingUTXOs"`
                                                                                                                                                                                                                                                                                              		MergingTransparentValue   float64 `json:"mergingTransparentValue"`
                                                                                                                                                                                                                                                                                              		MergingNotes              int     `json:"mergingNotes"`
                                                                                                                                                                                                                                                                                              		MergingShieldedValue      float64 `json:"mergingShieldedValue"`
                                                                                                                                                                                                                                                                                              		Opid                      string  `json:"opid"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZSendMany

                                                                                                                                                                                                                                                                                              type ZSendMany struct {
                                                                                                                                                                                                                                                                                              	Result string `json:"result"`
                                                                                                                                                                                                                                                                                              	Error  Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID     string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZShieldCoinbase

                                                                                                                                                                                                                                                                                              type ZShieldCoinbase struct {
                                                                                                                                                                                                                                                                                              	Result struct {
                                                                                                                                                                                                                                                                                              		RemainingUTXOs int     `json:"remainingUTXOs"`
                                                                                                                                                                                                                                                                                              		RemainingValue float64 `json:"remainingValue"`
                                                                                                                                                                                                                                                                                              		ShieldingUTXOs int     `json:"shieldingUTXOs"`
                                                                                                                                                                                                                                                                                              		ShieldingValue float64 `json:"shieldingValue"`
                                                                                                                                                                                                                                                                                              		Opid           string  `json:"opid"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              type ZValidateAddress

                                                                                                                                                                                                                                                                                              type ZValidateAddress struct {
                                                                                                                                                                                                                                                                                              	Result struct {
                                                                                                                                                                                                                                                                                              		Isvalid                    bool   `json:"isvalid"`
                                                                                                                                                                                                                                                                                              		Address                    string `json:"address"`
                                                                                                                                                                                                                                                                                              		Type                       string `json:"type"`
                                                                                                                                                                                                                                                                                              		Diversifier                string `json:"diversifier"`
                                                                                                                                                                                                                                                                                              		Diversifiedtransmissionkey string `json:"diversifiedtransmissionkey"`
                                                                                                                                                                                                                                                                                              		Ismine                     bool   `json:"ismine"`
                                                                                                                                                                                                                                                                                              	} `json:"result"`
                                                                                                                                                                                                                                                                                              	Error Error  `json:"error"`
                                                                                                                                                                                                                                                                                              	ID    string `json:"id"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                ZValidateAddress type

                                                                                                                                                                                                                                                                                                Directories

                                                                                                                                                                                                                                                                                                Path Synopsis
                                                                                                                                                                                                                                                                                                Package btcec implements support for the elliptic curves needed for bitcoin.
                                                                                                                                                                                                                                                                                                Package btcec implements support for the elliptic curves needed for bitcoin.
                                                                                                                                                                                                                                                                                                Package chaincfg defines chain configuration parameters.
                                                                                                                                                                                                                                                                                                Package chaincfg defines chain configuration parameters.
                                                                                                                                                                                                                                                                                                chainhash
                                                                                                                                                                                                                                                                                                Package chainhash provides abstracted hash functionality.
                                                                                                                                                                                                                                                                                                Package chainhash provides abstracted hash functionality.
                                                                                                                                                                                                                                                                                                examples
                                                                                                                                                                                                                                                                                                authkmd
                                                                                                                                                                                                                                                                                                kmdgo/kmdutils troubleshooting file
                                                                                                                                                                                                                                                                                                kmdgo/kmdutils troubleshooting file
                                                                                                                                                                                                                                                                                                base58
                                                                                                                                                                                                                                                                                                Package base58 provides an API for working with modified base58 and Base58Check encodings.
                                                                                                                                                                                                                                                                                                Package base58 provides an API for working with modified base58 and Base58Check encodings.
                                                                                                                                                                                                                                                                                                bech32
                                                                                                                                                                                                                                                                                                Package bech32 provides a Go implementation of the bech32 format specified in BIP 173.
                                                                                                                                                                                                                                                                                                Package bech32 provides a Go implementation of the bech32 format specified in BIP 173.
                                                                                                                                                                                                                                                                                                bip39
                                                                                                                                                                                                                                                                                                Package bip39 is the Golang implementation of the BIP39 spec.
                                                                                                                                                                                                                                                                                                Package bip39 is the Golang implementation of the BIP39 spec.
                                                                                                                                                                                                                                                                                                Package wire implements the bitcoin wire protocol.
                                                                                                                                                                                                                                                                                                Package wire implements the bitcoin wire protocol.