Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "c", "*", "Client", ")", "GetUnconfirmedBalanceAsync", "(", "account", "string", ")", "FutureGetUnconfirmedBalanceResult", "{", "cmd", ":=", "btcjson", ".", "NewGetUnconfirmedBalanceCmd", "(", "&", "account", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetUnconfirmedBalanceAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetUnconfirmedBalance", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetUnconfirmedBalance", "(", "account", "string", ")", "(", "btcutil", ".", "Amount", ",", "error", ")", "{", "return", "c", ".", "GetUnconfirmedBalanceAsync", "(", "account", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetUnconfirmedBalance", "returns", "the", "unconfirmed", "balance", "from", "the", "server", "for", "the", "specified", "account", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetReceivedByAddressAsync", "(", "address", "btcutil", ".", "Address", ")", "FutureGetReceivedByAddressResult", "{", "addr", ":=", "address", ".", "EncodeAddress", "(", ")", "\n", "cmd", ":=", "btcjson", ".", "NewGetReceivedByAddressCmd", "(", "addr", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n\n", "}" ]

[ "GetReceivedByAddressAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetReceivedByAddress", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetReceivedByAddress", "(", "address", "btcutil", ".", "Address", ")", "(", "btcutil", ".", "Amount", ",", "error", ")", "{", "return", "c", ".", "GetReceivedByAddressAsync", "(", "address", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetReceivedByAddress", "returns", "the", "total", "amount", "received", "by", "the", "specified", "address", "with", "at", "least", "the", "default", "number", "of", "minimum", "confirmations", ".", "See", "GetReceivedByAddressMinConf", "to", "override", "the", "minimum", "number", "of", "confirmations", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetReceivedByAddressMinConfAsync", "(", "address", "btcutil", ".", "Address", ",", "minConfirms", "int", ")", "FutureGetReceivedByAddressResult", "{", "addr", ":=", "address", ".", "EncodeAddress", "(", ")", "\n", "cmd", ":=", "btcjson", ".", "NewGetReceivedByAddressCmd", "(", "addr", ",", "&", "minConfirms", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetReceivedByAddressMinConfAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetReceivedByAddressMinConf", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetReceivedByAddressMinConf", "(", "address", "btcutil", ".", "Address", ",", "minConfirms", "int", ")", "(", "btcutil", ".", "Amount", ",", "error", ")", "{", "return", "c", ".", "GetReceivedByAddressMinConfAsync", "(", "address", ",", "minConfirms", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetReceivedByAddressMinConf", "returns", "the", "total", "amount", "received", "by", "the", "specified", "address", "with", "at", "least", "the", "specified", "number", "of", "minimum", "confirmations", ".", "See", "GetReceivedByAddress", "to", "use", "the", "default", "minimum", "number", "of", "confirmations", "." ]

[ "func", "(", "r", "FutureListReceivedByAccountResult", ")", "Receive", "(", ")", "(", "[", "]", "btcjson", ".", "ListReceivedByAccountResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal as an array of listreceivedbyaccount result objects.", "var", "received", "[", "]", "btcjson", ".", "ListReceivedByAccountResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "received", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "received", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "a", "list", "of", "balances", "by", "account", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAccountAsync", "(", ")", "FutureListReceivedByAccountResult", "{", "cmd", ":=", "btcjson", ".", "NewListReceivedByAccountCmd", "(", "nil", ",", "nil", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ListReceivedByAccountAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ListReceivedByAccount", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAccountMinConfAsync", "(", "minConfirms", "int", ")", "FutureListReceivedByAccountResult", "{", "cmd", ":=", "btcjson", ".", "NewListReceivedByAccountCmd", "(", "&", "minConfirms", ",", "nil", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ListReceivedByAccountMinConfAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ListReceivedByAccountMinConf", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAccountMinConf", "(", "minConfirms", "int", ")", "(", "[", "]", "btcjson", ".", "ListReceivedByAccountResult", ",", "error", ")", "{", "return", "c", ".", "ListReceivedByAccountMinConfAsync", "(", "minConfirms", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ListReceivedByAccountMinConf", "lists", "balances", "by", "account", "using", "the", "specified", "number", "of", "minimum", "confirmations", "not", "including", "accounts", "that", "haven", "t", "received", "any", "payments", ".", "See", "ListReceivedByAccount", "to", "use", "the", "default", "minimum", "number", "of", "confirmations", "and", "ListReceivedByAccountIncludeEmpty", "to", "also", "include", "accounts", "that", "haven", "t", "received", "any", "payments", "in", "the", "results", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAccountIncludeEmptyAsync", "(", "minConfirms", "int", ",", "includeEmpty", "bool", ")", "FutureListReceivedByAccountResult", "{", "cmd", ":=", "btcjson", ".", "NewListReceivedByAccountCmd", "(", "&", "minConfirms", ",", "&", "includeEmpty", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ListReceivedByAccountIncludeEmptyAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ListReceivedByAccountIncludeEmpty", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAccountIncludeEmpty", "(", "minConfirms", "int", ",", "includeEmpty", "bool", ")", "(", "[", "]", "btcjson", ".", "ListReceivedByAccountResult", ",", "error", ")", "{", "return", "c", ".", "ListReceivedByAccountIncludeEmptyAsync", "(", "minConfirms", ",", "includeEmpty", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ListReceivedByAccountIncludeEmpty", "lists", "balances", "by", "account", "using", "the", "specified", "number", "of", "minimum", "confirmations", "and", "including", "accounts", "that", "haven", "t", "received", "any", "payments", "depending", "on", "specified", "flag", ".", "See", "ListReceivedByAccount", "and", "ListReceivedByAccountMinConf", "to", "use", "defaults", "." ]

[ "func", "(", "r", "FutureListReceivedByAddressResult", ")", "Receive", "(", ")", "(", "[", "]", "btcjson", ".", "ListReceivedByAddressResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal as an array of listreceivedbyaddress result objects.", "var", "received", "[", "]", "btcjson", ".", "ListReceivedByAddressResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "received", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "received", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "a", "list", "of", "balances", "by", "address", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAddressAsync", "(", ")", "FutureListReceivedByAddressResult", "{", "cmd", ":=", "btcjson", ".", "NewListReceivedByAddressCmd", "(", "nil", ",", "nil", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ListReceivedByAddressAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ListReceivedByAddress", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAddressMinConfAsync", "(", "minConfirms", "int", ")", "FutureListReceivedByAddressResult", "{", "cmd", ":=", "btcjson", ".", "NewListReceivedByAddressCmd", "(", "&", "minConfirms", ",", "nil", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ListReceivedByAddressMinConfAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ListReceivedByAddressMinConf", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAddressMinConf", "(", "minConfirms", "int", ")", "(", "[", "]", "btcjson", ".", "ListReceivedByAddressResult", ",", "error", ")", "{", "return", "c", ".", "ListReceivedByAddressMinConfAsync", "(", "minConfirms", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ListReceivedByAddressMinConf", "lists", "balances", "by", "address", "using", "the", "specified", "number", "of", "minimum", "confirmations", "not", "including", "addresses", "that", "haven", "t", "received", "any", "payments", ".", "See", "ListReceivedByAddress", "to", "use", "the", "default", "minimum", "number", "of", "confirmations", "and", "ListReceivedByAddressIncludeEmpty", "to", "also", "include", "addresses", "that", "haven", "t", "received", "any", "payments", "in", "the", "results", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAddressIncludeEmptyAsync", "(", "minConfirms", "int", ",", "includeEmpty", "bool", ")", "FutureListReceivedByAddressResult", "{", "cmd", ":=", "btcjson", ".", "NewListReceivedByAddressCmd", "(", "&", "minConfirms", ",", "&", "includeEmpty", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ListReceivedByAddressIncludeEmptyAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ListReceivedByAccountIncludeEmpty", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ListReceivedByAddressIncludeEmpty", "(", "minConfirms", "int", ",", "includeEmpty", "bool", ")", "(", "[", "]", "btcjson", ".", "ListReceivedByAddressResult", ",", "error", ")", "{", "return", "c", ".", "ListReceivedByAddressIncludeEmptyAsync", "(", "minConfirms", ",", "includeEmpty", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ListReceivedByAddressIncludeEmpty", "lists", "balances", "by", "address", "using", "the", "specified", "number", "of", "minimum", "confirmations", "and", "including", "addresses", "that", "haven", "t", "received", "any", "payments", "depending", "on", "specified", "flag", ".", "See", "ListReceivedByAddress", "and", "ListReceivedByAddressMinConf", "to", "use", "defaults", "." ]

[ "func", "(", "c", "*", "Client", ")", "WalletLockAsync", "(", ")", "FutureWalletLockResult", "{", "cmd", ":=", "btcjson", ".", "NewWalletLockCmd", "(", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "WalletLockAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "WalletLock", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "WalletPassphraseChangeAsync", "(", "old", ",", "new", "string", ")", "FutureWalletPassphraseChangeResult", "{", "cmd", ":=", "btcjson", ".", "NewWalletPassphraseChangeCmd", "(", "old", ",", "new", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "WalletPassphraseChangeAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "WalletPassphraseChange", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "WalletPassphraseChange", "(", "old", ",", "new", "string", ")", "error", "{", "return", "c", ".", "WalletPassphraseChangeAsync", "(", "old", ",", "new", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "WalletPassphraseChange", "changes", "the", "wallet", "passphrase", "from", "the", "specified", "old", "to", "new", "passphrase", "." ]

[ "func", "(", "r", "FutureSignMessageResult", ")", "Receive", "(", ")", "(", "string", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as a string.", "var", "b64", "string", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "b64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "b64", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "message", "signed", "with", "the", "private", "key", "of", "the", "specified", "address", "." ]

[ "func", "(", "c", "*", "Client", ")", "SignMessageAsync", "(", "address", "btcutil", ".", "Address", ",", "message", "string", ")", "FutureSignMessageResult", "{", "addr", ":=", "address", ".", "EncodeAddress", "(", ")", "\n", "cmd", ":=", "btcjson", ".", "NewSignMessageCmd", "(", "addr", ",", "message", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "SignMessageAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "SignMessage", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "VerifyMessageAsync", "(", "address", "btcutil", ".", "Address", ",", "signature", ",", "message", "string", ")", "FutureVerifyMessageResult", "{", "addr", ":=", "address", ".", "EncodeAddress", "(", ")", "\n", "cmd", ":=", "btcjson", ".", "NewVerifyMessageCmd", "(", "addr", ",", "signature", ",", "message", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "VerifyMessageAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "VerifyMessage", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "DumpPrivKeyAsync", "(", "address", "btcutil", ".", "Address", ")", "FutureDumpPrivKeyResult", "{", "addr", ":=", "address", ".", "EncodeAddress", "(", ")", "\n", "cmd", ":=", "btcjson", ".", "NewDumpPrivKeyCmd", "(", "addr", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "DumpPrivKeyAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "DumpPrivKey", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportAddressAsync", "(", "address", "string", ")", "FutureImportAddressResult", "{", "cmd", ":=", "btcjson", ".", "NewImportAddressCmd", "(", "address", ",", "\"", "\"", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ImportAddressAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ImportAddress", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportAddress", "(", "address", "string", ")", "error", "{", "return", "c", ".", "ImportAddressAsync", "(", "address", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ImportAddress", "imports", "the", "passed", "public", "address", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportAddressRescanAsync", "(", "address", "string", ",", "account", "string", ",", "rescan", "bool", ")", "FutureImportAddressResult", "{", "cmd", ":=", "btcjson", ".", "NewImportAddressCmd", "(", "address", ",", "account", ",", "&", "rescan", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ImportAddressRescanAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ImportAddress", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportAddressRescan", "(", "address", "string", ",", "account", "string", ",", "rescan", "bool", ")", "error", "{", "return", "c", ".", "ImportAddressRescanAsync", "(", "address", ",", "account", ",", "rescan", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ImportAddressRescan", "imports", "the", "passed", "public", "address", ".", "When", "rescan", "is", "true", "the", "block", "history", "is", "scanned", "for", "transactions", "addressed", "to", "provided", "address", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportPrivKeyAsync", "(", "privKeyWIF", "*", "btcutil", ".", "WIF", ")", "FutureImportPrivKeyResult", "{", "wif", ":=", "\"", "\"", "\n", "if", "privKeyWIF", "!=", "nil", "{", "wif", "=", "privKeyWIF", ".", "String", "(", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewImportPrivKeyCmd", "(", "wif", ",", "nil", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ImportPrivKeyAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ImportPrivKey", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportPrivKeyLabelAsync", "(", "privKeyWIF", "*", "btcutil", ".", "WIF", ",", "label", "string", ")", "FutureImportPrivKeyResult", "{", "wif", ":=", "\"", "\"", "\n", "if", "privKeyWIF", "!=", "nil", "{", "wif", "=", "privKeyWIF", ".", "String", "(", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewImportPrivKeyCmd", "(", "wif", ",", "&", "label", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ImportPrivKeyLabelAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ImportPrivKey", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportPrivKeyRescanAsync", "(", "privKeyWIF", "*", "btcutil", ".", "WIF", ",", "label", "string", ",", "rescan", "bool", ")", "FutureImportPrivKeyResult", "{", "wif", ":=", "\"", "\"", "\n", "if", "privKeyWIF", "!=", "nil", "{", "wif", "=", "privKeyWIF", ".", "String", "(", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewImportPrivKeyCmd", "(", "wif", ",", "&", "label", ",", "&", "rescan", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ImportPrivKeyRescanAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ImportPrivKey", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportPubKeyAsync", "(", "pubKey", "string", ")", "FutureImportPubKeyResult", "{", "cmd", ":=", "btcjson", ".", "NewImportPubKeyCmd", "(", "pubKey", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ImportPubKeyAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ImportPubKey", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportPubKey", "(", "pubKey", "string", ")", "error", "{", "return", "c", ".", "ImportPubKeyAsync", "(", "pubKey", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ImportPubKey", "imports", "the", "passed", "public", "key", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportPubKeyRescanAsync", "(", "pubKey", "string", ",", "rescan", "bool", ")", "FutureImportPubKeyResult", "{", "cmd", ":=", "btcjson", ".", "NewImportPubKeyCmd", "(", "pubKey", ",", "&", "rescan", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "ImportPubKeyRescanAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "ImportPubKey", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "ImportPubKeyRescan", "(", "pubKey", "string", ",", "rescan", "bool", ")", "error", "{", "return", "c", ".", "ImportPubKeyRescanAsync", "(", "pubKey", ",", "rescan", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "ImportPubKeyRescan", "imports", "the", "passed", "public", "key", ".", "When", "rescan", "is", "true", "the", "block", "history", "is", "scanned", "for", "transactions", "addressed", "to", "provided", "pubkey", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetInfoAsync", "(", ")", "FutureGetInfoResult", "{", "cmd", ":=", "btcjson", ".", "NewGetInfoCmd", "(", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetInfoAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetInfo", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "removeDuplicateAddresses", "(", "addrs", "[", "]", "string", ")", "[", "]", "string", "{", "result", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "addrs", ")", ")", "\n", "seen", ":=", "map", "[", "string", "]", "struct", "{", "}", "{", "}", "\n", "for", "_", ",", "val", ":=", "range", "addrs", "{", "if", "_", ",", "ok", ":=", "seen", "[", "val", "]", ";", "!", "ok", "{", "result", "=", "append", "(", "result", ",", "val", ")", "\n", "seen", "[", "val", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "removeDuplicateAddresses", "returns", "a", "new", "slice", "with", "all", "duplicate", "entries", "in", "addrs", "removed", "." ]

[ "func", "normalizeAddresses", "(", "addrs", "[", "]", "string", ",", "defaultPort", "string", ")", "[", "]", "string", "{", "for", "i", ",", "addr", ":=", "range", "addrs", "{", "addrs", "[", "i", "]", "=", "normalizeAddress", "(", "addr", ",", "defaultPort", ")", "\n", "}", "\n\n", "return", "removeDuplicateAddresses", "(", "addrs", ")", "\n", "}" ]

[ "normalizeAddresses", "returns", "a", "new", "slice", "with", "all", "the", "passed", "peer", "addresses", "normalized", "with", "the", "given", "default", "port", "and", "all", "duplicates", "removed", "." ]

[ "func", "newConfigParser", "(", "cfg", "*", "config", ",", "so", "*", "serviceOptions", ",", "options", "flags", ".", "Options", ")", "*", "flags", ".", "Parser", "{", "parser", ":=", "flags", ".", "NewParser", "(", "cfg", ",", "options", ")", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "parser", ".", "AddGroup", "(", "\"", "\"", ",", "\"", "\"", ",", "so", ")", "\n", "}", "\n", "return", "parser", "\n", "}" ]

[ "newConfigParser", "returns", "a", "new", "command", "line", "flags", "parser", "." ]

[ "func", "createDefaultConfigFile", "(", "destinationPath", "string", ")", "error", "{", "// Create the destination directory if it does not exists", "err", ":=", "os", ".", "MkdirAll", "(", "filepath", ".", "Dir", "(", "destinationPath", ")", ",", "0700", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// We assume sample config file path is same as binary", "path", ",", "err", ":=", "filepath", ".", "Abs", "(", "filepath", ".", "Dir", "(", "os", ".", "Args", "[", "0", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sampleConfigPath", ":=", "filepath", ".", "Join", "(", "path", ",", "sampleConfigFilename", ")", "\n\n", "// We generate a random user and password", "randomBytes", ":=", "make", "(", "[", "]", "byte", ",", "20", ")", "\n", "_", ",", "err", "=", "rand", ".", "Read", "(", "randomBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "generatedRPCUser", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "randomBytes", ")", "\n\n", "_", ",", "err", "=", "rand", ".", "Read", "(", "randomBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "generatedRPCPass", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "randomBytes", ")", "\n\n", "src", ",", "err", ":=", "os", ".", "Open", "(", "sampleConfigPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "src", ".", "Close", "(", ")", "\n\n", "dest", ",", "err", ":=", "os", ".", "OpenFile", "(", "destinationPath", ",", "os", ".", "O_RDWR", "|", "os", ".", "O_CREATE", "|", "os", ".", "O_TRUNC", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "dest", ".", "Close", "(", ")", "\n\n", "// We copy every line from the sample config file to the destination,", "// only replacing the two lines for rpcuser and rpcpass", "reader", ":=", "bufio", ".", "NewReader", "(", "src", ")", "\n", "for", "err", "!=", "io", ".", "EOF", "{", "var", "line", "string", "\n", "line", ",", "err", "=", "reader", ".", "ReadString", "(", "'\\n'", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "return", "err", "\n", "}", "\n\n", "if", "strings", ".", "Contains", "(", "line", ",", "\"", "\"", ")", "{", "line", "=", "\"", "\"", "+", "generatedRPCUser", "+", "\"", "\\n", "\"", "\n", "}", "else", "if", "strings", ".", "Contains", "(", "line", ",", "\"", "\"", ")", "{", "line", "=", "\"", "\"", "+", "generatedRPCPass", "+", "\"", "\\n", "\"", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "dest", ".", "WriteString", "(", "line", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "createDefaultConfig", "copies", "the", "file", "sample", "-", "btcd", ".", "conf", "to", "the", "given", "destination", "path", "and", "populates", "it", "with", "some", "randomly", "generated", "RPC", "username", "and", "password", "." ]

[ "func", "(", "h", "*", "BlockHeader", ")", "BlockHash", "(", ")", "chainhash", ".", "Hash", "{", "// Encode the header and double sha256 everything prior to the number of", "// transactions. Ignore the error returns since there is no way the", "// encode could fail except being out of memory which would cause a", "// run-time panic.", "buf", ":=", "bytes", ".", "NewBuffer", "(", "make", "(", "[", "]", "byte", ",", "0", ",", "MaxBlockHeaderPayload", ")", ")", "\n", "_", "=", "writeBlockHeader", "(", "buf", ",", "0", ",", "h", ")", "\n\n", "return", "chainhash", ".", "DoubleHashH", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "}" ]

[ "BlockHash", "computes", "the", "block", "identifier", "hash", "for", "the", "given", "block", "header", "." ]

[ "func", "(", "h", "*", "BlockHeader", ")", "BtcDecode", "(", "r", "io", ".", "Reader", ",", "pver", "uint32", ",", "enc", "MessageEncoding", ")", "error", "{", "return", "readBlockHeader", "(", "r", ",", "pver", ",", "h", ")", "\n", "}" ]

[ "BtcDecode", "decodes", "r", "using", "the", "bitcoin", "protocol", "encoding", "into", "the", "receiver", ".", "This", "is", "part", "of", "the", "Message", "interface", "implementation", ".", "See", "Deserialize", "for", "decoding", "block", "headers", "stored", "to", "disk", "such", "as", "in", "a", "database", "as", "opposed", "to", "decoding", "block", "headers", "from", "the", "wire", "." ]

[ "func", "(", "h", "*", "BlockHeader", ")", "BtcEncode", "(", "w", "io", ".", "Writer", ",", "pver", "uint32", ",", "enc", "MessageEncoding", ")", "error", "{", "return", "writeBlockHeader", "(", "w", ",", "pver", ",", "h", ")", "\n", "}" ]

[ "BtcEncode", "encodes", "the", "receiver", "to", "w", "using", "the", "bitcoin", "protocol", "encoding", ".", "This", "is", "part", "of", "the", "Message", "interface", "implementation", ".", "See", "Serialize", "for", "encoding", "block", "headers", "to", "be", "stored", "to", "disk", "such", "as", "in", "a", "database", "as", "opposed", "to", "encoding", "block", "headers", "for", "the", "wire", "." ]

[ "func", "(", "h", "*", "BlockHeader", ")", "Deserialize", "(", "r", "io", ".", "Reader", ")", "error", "{", "// At the current time, there is no difference between the wire encoding", "// at protocol version 0 and the stable long-term storage format. As", "// a result, make use of readBlockHeader.", "return", "readBlockHeader", "(", "r", ",", "0", ",", "h", ")", "\n", "}" ]

[ "Deserialize", "decodes", "a", "block", "header", "from", "r", "into", "the", "receiver", "using", "a", "format", "that", "is", "suitable", "for", "long", "-", "term", "storage", "such", "as", "a", "database", "while", "respecting", "the", "Version", "field", "." ]

[ "func", "(", "h", "*", "BlockHeader", ")", "Serialize", "(", "w", "io", ".", "Writer", ")", "error", "{", "// At the current time, there is no difference between the wire encoding", "// at protocol version 0 and the stable long-term storage format. As", "// a result, make use of writeBlockHeader.", "return", "writeBlockHeader", "(", "w", ",", "0", ",", "h", ")", "\n", "}" ]

[ "Serialize", "encodes", "a", "block", "header", "from", "r", "into", "the", "receiver", "using", "a", "format", "that", "is", "suitable", "for", "long", "-", "term", "storage", "such", "as", "a", "database", "while", "respecting", "the", "Version", "field", "." ]

[ "func", "NewBlockHeader", "(", "version", "int32", ",", "prevHash", ",", "merkleRootHash", "*", "chainhash", ".", "Hash", ",", "bits", "uint32", ",", "nonce", "uint32", ")", "*", "BlockHeader", "{", "// Limit the timestamp to one second precision since the protocol", "// doesn't support better.", "return", "&", "BlockHeader", "{", "Version", ":", "version", ",", "PrevBlock", ":", "*", "prevHash", ",", "MerkleRoot", ":", "*", "merkleRootHash", ",", "Timestamp", ":", "time", ".", "Unix", "(", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "0", ")", ",", "Bits", ":", "bits", ",", "Nonce", ":", "nonce", ",", "}", "\n", "}" ]

[ "NewBlockHeader", "returns", "a", "new", "BlockHeader", "using", "the", "provided", "version", "previous", "block", "hash", "merkle", "root", "hash", "difficulty", "bits", "and", "nonce", "used", "to", "generate", "the", "block", "with", "defaults", "for", "the", "remaining", "fields", "." ]

[ "func", "readBlockHeader", "(", "r", "io", ".", "Reader", ",", "pver", "uint32", ",", "bh", "*", "BlockHeader", ")", "error", "{", "return", "readElements", "(", "r", ",", "&", "bh", ".", "Version", ",", "&", "bh", ".", "PrevBlock", ",", "&", "bh", ".", "MerkleRoot", ",", "(", "*", "uint32Time", ")", "(", "&", "bh", ".", "Timestamp", ")", ",", "&", "bh", ".", "Bits", ",", "&", "bh", ".", "Nonce", ")", "\n", "}" ]

[ "readBlockHeader", "reads", "a", "bitcoin", "block", "header", "from", "r", ".", "See", "Deserialize", "for", "decoding", "block", "headers", "stored", "to", "disk", "such", "as", "in", "a", "database", "as", "opposed", "to", "decoding", "from", "the", "wire", "." ]

[ "func", "writeBlockHeader", "(", "w", "io", ".", "Writer", ",", "pver", "uint32", ",", "bh", "*", "BlockHeader", ")", "error", "{", "sec", ":=", "uint32", "(", "bh", ".", "Timestamp", ".", "Unix", "(", ")", ")", "\n", "return", "writeElements", "(", "w", ",", "bh", ".", "Version", ",", "&", "bh", ".", "PrevBlock", ",", "&", "bh", ".", "MerkleRoot", ",", "sec", ",", "bh", ".", "Bits", ",", "bh", ".", "Nonce", ")", "\n", "}" ]

[ "writeBlockHeader", "writes", "a", "bitcoin", "block", "header", "to", "w", ".", "See", "Serialize", "for", "encoding", "block", "headers", "to", "be", "stored", "to", "disk", "such", "as", "in", "a", "database", "as", "opposed", "to", "encoding", "for", "the", "wire", "." ]

[ "func", "init", "(", ")", "{", "for", "i", ":=", "range", "precomputedFactor", "{", "precomputedFactor", "[", "i", "]", "=", "math", ".", "Exp", "(", "-", "1.0", "*", "float64", "(", "i", ")", "*", "lambda", ")", "\n", "}", "\n", "}" ]

[ "init", "precomputes", "decay", "factors", "." ]

[ "func", "decayFactor", "(", "t", "int64", ")", "float64", "{", "if", "t", "<", "precomputedLen", "{", "return", "precomputedFactor", "[", "t", "]", "\n", "}", "\n", "return", "math", ".", "Exp", "(", "-", "1.0", "*", "float64", "(", "t", ")", "*", "lambda", ")", "\n", "}" ]

[ "decayFactor", "returns", "the", "decay", "factor", "at", "t", "seconds", "using", "precalculated", "values", "if", "available", "or", "calculating", "the", "factor", "if", "needed", "." ]

[ "func", "(", "s", "*", "DynamicBanScore", ")", "String", "(", ")", "string", "{", "s", ".", "mtx", ".", "Lock", "(", ")", "\n", "r", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "persistent", ",", "s", ".", "transient", ",", "s", ".", "lastUnix", ",", "s", ".", "Int", "(", ")", ")", "\n", "s", ".", "mtx", ".", "Unlock", "(", ")", "\n", "return", "r", "\n", "}" ]

[ "String", "returns", "the", "ban", "score", "as", "a", "human", "-", "readable", "string", "." ]

[ "func", "(", "s", "*", "DynamicBanScore", ")", "Int", "(", ")", "uint32", "{", "s", ".", "mtx", ".", "Lock", "(", ")", "\n", "r", ":=", "s", ".", "int", "(", "time", ".", "Now", "(", ")", ")", "\n", "s", ".", "mtx", ".", "Unlock", "(", ")", "\n", "return", "r", "\n", "}" ]

[ "Int", "returns", "the", "current", "ban", "score", "the", "sum", "of", "the", "persistent", "and", "decaying", "scores", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "s", "*", "DynamicBanScore", ")", "Increase", "(", "persistent", ",", "transient", "uint32", ")", "uint32", "{", "s", ".", "mtx", ".", "Lock", "(", ")", "\n", "r", ":=", "s", ".", "increase", "(", "persistent", ",", "transient", ",", "time", ".", "Now", "(", ")", ")", "\n", "s", ".", "mtx", ".", "Unlock", "(", ")", "\n", "return", "r", "\n", "}" ]

[ "Increase", "increases", "both", "the", "persistent", "and", "decaying", "scores", "by", "the", "values", "passed", "as", "parameters", ".", "The", "resulting", "score", "is", "returned", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "s", "*", "DynamicBanScore", ")", "Reset", "(", ")", "{", "s", ".", "mtx", ".", "Lock", "(", ")", "\n", "s", ".", "persistent", "=", "0", "\n", "s", ".", "transient", "=", "0", "\n", "s", ".", "lastUnix", "=", "0", "\n", "s", ".", "mtx", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Reset", "set", "both", "persistent", "and", "decaying", "scores", "to", "zero", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "s", "*", "DynamicBanScore", ")", "int", "(", "t", "time", ".", "Time", ")", "uint32", "{", "dt", ":=", "t", ".", "Unix", "(", ")", "-", "s", ".", "lastUnix", "\n", "if", "s", ".", "transient", "<", "1", "||", "dt", "<", "0", "||", "Lifetime", "<", "dt", "{", "return", "s", ".", "persistent", "\n", "}", "\n", "return", "s", ".", "persistent", "+", "uint32", "(", "s", ".", "transient", "*", "decayFactor", "(", "dt", ")", ")", "\n", "}" ]

[ "int", "returns", "the", "ban", "score", "the", "sum", "of", "the", "persistent", "and", "decaying", "scores", "at", "a", "given", "point", "in", "time", ".", "This", "function", "is", "not", "safe", "for", "concurrent", "access", ".", "It", "is", "intended", "to", "be", "used", "internally", "and", "during", "testing", "." ]

[ "func", "(", "s", "*", "DynamicBanScore", ")", "increase", "(", "persistent", ",", "transient", "uint32", ",", "t", "time", ".", "Time", ")", "uint32", "{", "s", ".", "persistent", "+=", "persistent", "\n", "tu", ":=", "t", ".", "Unix", "(", ")", "\n", "dt", ":=", "tu", "-", "s", ".", "lastUnix", "\n\n", "if", "transient", ">", "0", "{", "if", "Lifetime", "<", "dt", "{", "s", ".", "transient", "=", "0", "\n", "}", "else", "if", "s", ".", "transient", ">", "1", "&&", "dt", ">", "0", "{", "s", ".", "transient", "*=", "decayFactor", "(", "dt", ")", "\n", "}", "\n", "s", ".", "transient", "+=", "float64", "(", "transient", ")", "\n", "s", ".", "lastUnix", "=", "tu", "\n", "}", "\n", "return", "s", ".", "persistent", "+", "uint32", "(", "s", ".", "transient", ")", "\n", "}" ]

[ "increase", "increases", "the", "persistent", "the", "decaying", "or", "both", "scores", "by", "the", "values", "passed", "as", "parameters", ".", "The", "resulting", "score", "is", "calculated", "as", "if", "the", "action", "was", "carried", "out", "at", "the", "point", "time", "represented", "by", "the", "third", "parameter", ".", "The", "resulting", "score", "is", "returned", ".", "This", "function", "is", "not", "safe", "for", "concurrent", "access", "." ]

[ "func", "newHTTPClient", "(", "cfg", "*", "config", ")", "(", "*", "http", ".", "Client", ",", "error", ")", "{", "// Configure proxy if needed.", "var", "dial", "func", "(", "network", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "\n", "if", "cfg", ".", "Proxy", "!=", "\"", "\"", "{", "proxy", ":=", "&", "socks", ".", "Proxy", "{", "Addr", ":", "cfg", ".", "Proxy", ",", "Username", ":", "cfg", ".", "ProxyUser", ",", "Password", ":", "cfg", ".", "ProxyPass", ",", "}", "\n", "dial", "=", "func", "(", "network", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "c", ",", "err", ":=", "proxy", ".", "Dial", "(", "network", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "c", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Configure TLS if needed.", "var", "tlsConfig", "*", "tls", ".", "Config", "\n", "if", "!", "cfg", ".", "NoTLS", "&&", "cfg", ".", "RPCCert", "!=", "\"", "\"", "{", "pem", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "cfg", ".", "RPCCert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "pool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n", "pool", ".", "AppendCertsFromPEM", "(", "pem", ")", "\n", "tlsConfig", "=", "&", "tls", ".", "Config", "{", "RootCAs", ":", "pool", ",", "InsecureSkipVerify", ":", "cfg", ".", "TLSSkipVerify", ",", "}", "\n", "}", "\n\n", "// Create and return the new HTTP client potentially configured with a", "// proxy and TLS.", "client", ":=", "http", ".", "Client", "{", "Transport", ":", "&", "http", ".", "Transport", "{", "Dial", ":", "dial", ",", "TLSClientConfig", ":", "tlsConfig", ",", "}", ",", "}", "\n", "return", "&", "client", ",", "nil", "\n", "}" ]

[ "newHTTPClient", "returns", "a", "new", "HTTP", "client", "that", "is", "configured", "according", "to", "the", "proxy", "and", "TLS", "settings", "in", "the", "associated", "connection", "configuration", "." ]

[ "func", "sendPostRequest", "(", "marshalledJSON", "[", "]", "byte", ",", "cfg", "*", "config", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Generate a request to the configured RPC server.", "protocol", ":=", "\"", "\"", "\n", "if", "!", "cfg", ".", "NoTLS", "{", "protocol", "=", "\"", "\"", "\n", "}", "\n", "url", ":=", "protocol", "+", "\"", "\"", "+", "cfg", ".", "RPCServer", "\n", "bodyReader", ":=", "bytes", ".", "NewReader", "(", "marshalledJSON", ")", "\n", "httpRequest", ",", "err", ":=", "http", ".", "NewRequest", "(", "\"", "\"", ",", "url", ",", "bodyReader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "httpRequest", ".", "Close", "=", "true", "\n", "httpRequest", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "// Configure basic access authorization.", "httpRequest", ".", "SetBasicAuth", "(", "cfg", ".", "RPCUser", ",", "cfg", ".", "RPCPassword", ")", "\n\n", "// Create the new HTTP client that is configured according to the user-", "// specified options and submit the request.", "httpClient", ",", "err", ":=", "newHTTPClient", "(", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "httpResponse", ",", "err", ":=", "httpClient", ".", "Do", "(", "httpRequest", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Read the raw bytes and close the response.", "respBytes", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "httpResponse", ".", "Body", ")", "\n", "httpResponse", ".", "Body", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Handle unsuccessful HTTP responses", "if", "httpResponse", ".", "StatusCode", "<", "200", "||", "httpResponse", ".", "StatusCode", ">=", "300", "{", "// Generate a standard error to return if the server body is", "// empty. This should not happen very often, but it's better", "// than showing nothing in case the target server has a poor", "// implementation.", "if", "len", "(", "respBytes", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "httpResponse", ".", "StatusCode", ",", "http", ".", "StatusText", "(", "httpResponse", ".", "StatusCode", ")", ")", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "respBytes", ")", "\n", "}", "\n\n", "// Unmarshal the response.", "var", "resp", "btcjson", ".", "Response", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "respBytes", ",", "&", "resp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "resp", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "resp", ".", "Error", "\n", "}", "\n", "return", "resp", ".", "Result", ",", "nil", "\n", "}" ]

[ "sendPostRequest", "sends", "the", "marshalled", "JSON", "-", "RPC", "command", "using", "HTTP", "-", "POST", "mode", "to", "the", "server", "described", "in", "the", "passed", "config", "struct", ".", "It", "also", "attempts", "to", "unmarshal", "the", "response", "as", "a", "JSON", "-", "RPC", "response", "and", "returns", "either", "the", "result", "field", "or", "the", "error", "field", "depending", "on", "whether", "or", "not", "there", "is", "an", "error", "." ]

[ "func", "(", "c", "*", "Client", ")", "addRequest", "(", "jReq", "*", "jsonRequest", ")", "error", "{", "c", ".", "requestLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "requestLock", ".", "Unlock", "(", ")", "\n\n", "// A non-blocking read of the shutdown channel with the request lock", "// held avoids adding the request to the client's internal data", "// structures if the client is in the process of shutting down (and", "// has not yet grabbed the request lock), or has finished shutdown", "// already (responding to each outstanding request with", "// ErrClientShutdown).", "select", "{", "case", "<-", "c", ".", "shutdown", ":", "return", "ErrClientShutdown", "\n", "default", ":", "}", "\n\n", "element", ":=", "c", ".", "requestList", ".", "PushBack", "(", "jReq", ")", "\n", "c", ".", "requestMap", "[", "jReq", ".", "id", "]", "=", "element", "\n", "return", "nil", "\n", "}" ]

[ "addRequest", "associates", "the", "passed", "jsonRequest", "with", "its", "id", ".", "This", "allows", "the", "response", "from", "the", "remote", "server", "to", "be", "unmarshalled", "to", "the", "appropriate", "type", "and", "sent", "to", "the", "specified", "channel", "when", "it", "is", "received", ".", "If", "the", "client", "has", "already", "begun", "shutting", "down", "ErrClientShutdown", "is", "returned", "and", "the", "request", "is", "not", "added", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "c", "*", "Client", ")", "removeRequest", "(", "id", "uint64", ")", "*", "jsonRequest", "{", "c", ".", "requestLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "requestLock", ".", "Unlock", "(", ")", "\n\n", "element", ":=", "c", ".", "requestMap", "[", "id", "]", "\n", "if", "element", "!=", "nil", "{", "delete", "(", "c", ".", "requestMap", ",", "id", ")", "\n", "request", ":=", "c", ".", "requestList", ".", "Remove", "(", "element", ")", ".", "(", "*", "jsonRequest", ")", "\n", "return", "request", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "removeRequest", "returns", "and", "removes", "the", "jsonRequest", "which", "contains", "the", "response", "channel", "and", "original", "method", "associated", "with", "the", "passed", "id", "or", "nil", "if", "there", "is", "no", "association", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "c", "*", "Client", ")", "removeAllRequests", "(", ")", "{", "c", ".", "requestMap", "=", "make", "(", "map", "[", "uint64", "]", "*", "list", ".", "Element", ")", "\n", "c", ".", "requestList", ".", "Init", "(", ")", "\n", "}" ]

[ "removeAllRequests", "removes", "all", "the", "jsonRequests", "which", "contain", "the", "response", "channels", "for", "outstanding", "requests", ".", "This", "function", "MUST", "be", "called", "with", "the", "request", "lock", "held", "." ]

[ "func", "(", "c", "*", "Client", ")", "trackRegisteredNtfns", "(", "cmd", "interface", "{", "}", ")", "{", "// Nothing to do if the caller is not interested in notifications.", "if", "c", ".", "ntfnHandlers", "==", "nil", "{", "return", "\n", "}", "\n\n", "c", ".", "ntfnStateLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "ntfnStateLock", ".", "Unlock", "(", ")", "\n\n", "switch", "bcmd", ":=", "cmd", ".", "(", "type", ")", "{", "case", "*", "btcjson", ".", "NotifyBlocksCmd", ":", "c", ".", "ntfnState", ".", "notifyBlocks", "=", "true", "\n\n", "case", "*", "btcjson", ".", "NotifyNewTransactionsCmd", ":", "if", "bcmd", ".", "Verbose", "!=", "nil", "&&", "*", "bcmd", ".", "Verbose", "{", "c", ".", "ntfnState", ".", "notifyNewTxVerbose", "=", "true", "\n", "}", "else", "{", "c", ".", "ntfnState", ".", "notifyNewTx", "=", "true", "\n\n", "}", "\n\n", "case", "*", "btcjson", ".", "NotifySpentCmd", ":", "for", "_", ",", "op", ":=", "range", "bcmd", ".", "OutPoints", "{", "c", ".", "ntfnState", ".", "notifySpent", "[", "op", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "case", "*", "btcjson", ".", "NotifyReceivedCmd", ":", "for", "_", ",", "addr", ":=", "range", "bcmd", ".", "Addresses", "{", "c", ".", "ntfnState", ".", "notifyReceived", "[", "addr", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "trackRegisteredNtfns", "examines", "the", "passed", "command", "to", "see", "if", "it", "is", "one", "of", "the", "notification", "commands", "and", "updates", "the", "notification", "state", "that", "is", "used", "to", "automatically", "re", "-", "establish", "registered", "notifications", "on", "reconnects", "." ]

[ "func", "(", "c", "*", "Client", ")", "handleMessage", "(", "msg", "[", "]", "byte", ")", "{", "// Attempt to unmarshal the message as either a notification or", "// response.", "var", "in", "inMessage", "\n", "in", ".", "rawResponse", "=", "new", "(", "rawResponse", ")", "\n", "in", ".", "rawNotification", "=", "new", "(", "rawNotification", ")", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "msg", ",", "&", "in", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// JSON-RPC 1.0 notifications are requests with a null id.", "if", "in", ".", "ID", "==", "nil", "{", "ntfn", ":=", "in", ".", "rawNotification", "\n", "if", "ntfn", "==", "nil", "{", "log", ".", "Warn", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "if", "ntfn", ".", "Method", "==", "\"", "\"", "{", "log", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "// params are not optional: nil isn't valid (but len == 0 is)", "if", "ntfn", ".", "Params", "==", "nil", "{", "log", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "// Deliver the notification.", "log", ".", "Tracef", "(", "\"", "\"", ",", "in", ".", "Method", ")", "\n", "c", ".", "handleNotification", "(", "in", ".", "rawNotification", ")", "\n", "return", "\n", "}", "\n\n", "// ensure that in.ID can be converted to an integer without loss of precision", "if", "*", "in", ".", "ID", "<", "0", "||", "*", "in", ".", "ID", "!=", "math", ".", "Trunc", "(", "*", "in", ".", "ID", ")", "{", "log", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "if", "in", ".", "rawResponse", "==", "nil", "{", "log", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "id", ":=", "uint64", "(", "*", "in", ".", "ID", ")", "\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "id", ",", "in", ".", "Result", ")", "\n", "request", ":=", "c", ".", "removeRequest", "(", "id", ")", "\n\n", "// Nothing more to do if there is no request associated with this reply.", "if", "request", "==", "nil", "||", "request", ".", "responseChan", "==", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "in", ".", "Result", ",", "id", ")", "\n", "return", "\n", "}", "\n\n", "// Since the command was successful, examine it to see if it's a", "// notification, and if is, add it to the notification state so it", "// can automatically be re-established on reconnect.", "c", ".", "trackRegisteredNtfns", "(", "request", ".", "cmd", ")", "\n\n", "// Deliver the response.", "result", ",", "err", ":=", "in", ".", "rawResponse", ".", "result", "(", ")", "\n", "request", ".", "responseChan", "<-", "&", "response", "{", "result", ":", "result", ",", "err", ":", "err", "}", "\n", "}" ]

[ "handleMessage", "is", "the", "main", "handler", "for", "incoming", "notifications", "and", "responses", "." ]

[ "func", "(", "c", "*", "Client", ")", "shouldLogReadError", "(", "err", "error", ")", "bool", "{", "// No logging when the connetion is being forcibly disconnected.", "select", "{", "case", "<-", "c", ".", "shutdown", ":", "return", "false", "\n", "default", ":", "}", "\n\n", "// No logging when the connection has been disconnected.", "if", "err", "==", "io", ".", "EOF", "{", "return", "false", "\n", "}", "\n", "if", "opErr", ",", "ok", ":=", "err", ".", "(", "*", "net", ".", "OpError", ")", ";", "ok", "&&", "!", "opErr", ".", "Temporary", "(", ")", "{", "return", "false", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "shouldLogReadError", "returns", "whether", "or", "not", "the", "passed", "error", "which", "is", "expected", "to", "have", "come", "from", "reading", "from", "the", "websocket", "connection", "in", "wsInHandler", "should", "be", "logged", "." ]

[ "func", "(", "c", "*", "Client", ")", "wsInHandler", "(", ")", "{", "out", ":", "for", "{", "// Break out of the loop once the shutdown channel has been", "// closed. Use a non-blocking select here so we fall through", "// otherwise.", "select", "{", "case", "<-", "c", ".", "shutdown", ":", "break", "out", "\n", "default", ":", "}", "\n\n", "_", ",", "msg", ",", "err", ":=", "c", ".", "wsConn", ".", "ReadMessage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// Log the error if it's not due to disconnecting.", "if", "c", ".", "shouldLogReadError", "(", "err", ")", "{", "log", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "c", ".", "config", ".", "Host", ",", "err", ")", "\n", "}", "\n", "break", "out", "\n", "}", "\n", "c", ".", "handleMessage", "(", "msg", ")", "\n", "}", "\n\n", "// Ensure the connection is closed.", "c", ".", "Disconnect", "(", ")", "\n", "c", ".", "wg", ".", "Done", "(", ")", "\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "c", ".", "config", ".", "Host", ")", "\n", "}" ]

[ "wsInHandler", "handles", "all", "incoming", "messages", "for", "the", "websocket", "connection", "associated", "with", "the", "client", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "c", "*", "Client", ")", "disconnectChan", "(", ")", "<-", "chan", "struct", "{", "}", "{", "c", ".", "mtx", ".", "Lock", "(", ")", "\n", "ch", ":=", "c", ".", "disconnect", "\n", "c", ".", "mtx", ".", "Unlock", "(", ")", "\n", "return", "ch", "\n", "}" ]

[ "disconnectChan", "returns", "a", "copy", "of", "the", "current", "disconnect", "channel", ".", "The", "channel", "is", "read", "protected", "by", "the", "client", "mutex", "and", "is", "safe", "to", "call", "while", "the", "channel", "is", "being", "reassigned", "during", "a", "reconnect", "." ]

[ "func", "(", "c", "*", "Client", ")", "wsOutHandler", "(", ")", "{", "out", ":", "for", "{", "// Send any messages ready for send until the client is", "// disconnected closed.", "select", "{", "case", "msg", ":=", "<-", "c", ".", "sendChan", ":", "err", ":=", "c", ".", "wsConn", ".", "WriteMessage", "(", "websocket", ".", "TextMessage", ",", "msg", ")", "\n", "if", "err", "!=", "nil", "{", "c", ".", "Disconnect", "(", ")", "\n", "break", "out", "\n", "}", "\n\n", "case", "<-", "c", ".", "disconnectChan", "(", ")", ":", "break", "out", "\n", "}", "\n", "}", "\n\n", "// Drain any channels before exiting so nothing is left waiting around", "// to send.", "cleanup", ":", "for", "{", "select", "{", "case", "<-", "c", ".", "sendChan", ":", "default", ":", "break", "cleanup", "\n", "}", "\n", "}", "\n", "c", ".", "wg", ".", "Done", "(", ")", "\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "c", ".", "config", ".", "Host", ")", "\n", "}" ]

[ "wsOutHandler", "handles", "all", "outgoing", "messages", "for", "the", "websocket", "connection", ".", "It", "uses", "a", "buffered", "channel", "to", "serialize", "output", "messages", "while", "allowing", "the", "sender", "to", "continue", "running", "asynchronously", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "c", "*", "Client", ")", "sendMessage", "(", "marshalledJSON", "[", "]", "byte", ")", "{", "// Don't send the message if disconnected.", "select", "{", "case", "c", ".", "sendChan", "<-", "marshalledJSON", ":", "case", "<-", "c", ".", "disconnectChan", "(", ")", ":", "return", "\n", "}", "\n", "}" ]

[ "sendMessage", "sends", "the", "passed", "JSON", "to", "the", "connected", "server", "using", "the", "websocket", "connection", ".", "It", "is", "backed", "by", "a", "buffered", "channel", "so", "it", "will", "not", "block", "until", "the", "send", "channel", "is", "full", "." ]

[ "func", "(", "c", "*", "Client", ")", "reregisterNtfns", "(", ")", "error", "{", "// Nothing to do if the caller is not interested in notifications.", "if", "c", ".", "ntfnHandlers", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// In order to avoid holding the lock on the notification state for the", "// entire time of the potentially long running RPCs issued below, make a", "// copy of it and work from that.", "//", "// Also, other commands will be running concurrently which could modify", "// the notification state (while not under the lock of course) which", "// also register it with the remote RPC server, so this prevents double", "// registrations.", "c", ".", "ntfnStateLock", ".", "Lock", "(", ")", "\n", "stateCopy", ":=", "c", ".", "ntfnState", ".", "Copy", "(", ")", "\n", "c", ".", "ntfnStateLock", ".", "Unlock", "(", ")", "\n\n", "// Reregister notifyblocks if needed.", "if", "stateCopy", ".", "notifyBlocks", "{", "log", ".", "Debugf", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "c", ".", "NotifyBlocks", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Reregister notifynewtransactions if needed.", "if", "stateCopy", ".", "notifyNewTx", "||", "stateCopy", ".", "notifyNewTxVerbose", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "stateCopy", ".", "notifyNewTxVerbose", ")", "\n", "err", ":=", "c", ".", "NotifyNewTransactions", "(", "stateCopy", ".", "notifyNewTxVerbose", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Reregister the combination of all previously registered notifyspent", "// outpoints in one command if needed.", "nslen", ":=", "len", "(", "stateCopy", ".", "notifySpent", ")", "\n", "if", "nslen", ">", "0", "{", "outpoints", ":=", "make", "(", "[", "]", "btcjson", ".", "OutPoint", ",", "0", ",", "nslen", ")", "\n", "for", "op", ":=", "range", "stateCopy", ".", "notifySpent", "{", "outpoints", "=", "append", "(", "outpoints", ",", "op", ")", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "outpoints", ")", "\n", "if", "err", ":=", "c", ".", "notifySpentInternal", "(", "outpoints", ")", ".", "Receive", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Reregister the combination of all previously registered", "// notifyreceived addresses in one command if needed.", "nrlen", ":=", "len", "(", "stateCopy", ".", "notifyReceived", ")", "\n", "if", "nrlen", ">", "0", "{", "addresses", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "nrlen", ")", "\n", "for", "addr", ":=", "range", "stateCopy", ".", "notifyReceived", "{", "addresses", "=", "append", "(", "addresses", ",", "addr", ")", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "addresses", ")", "\n", "if", "err", ":=", "c", ".", "notifyReceivedInternal", "(", "addresses", ")", ".", "Receive", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "reregisterNtfns", "creates", "and", "sends", "commands", "needed", "to", "re", "-", "establish", "the", "current", "notification", "state", "associated", "with", "the", "client", ".", "It", "should", "only", "be", "called", "on", "on", "reconnect", "by", "the", "resendRequests", "function", "." ]

[ "func", "(", "c", "*", "Client", ")", "resendRequests", "(", ")", "{", "// Set the notification state back up. If anything goes wrong,", "// disconnect the client.", "if", "err", ":=", "c", ".", "reregisterNtfns", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "c", ".", "Disconnect", "(", ")", "\n", "return", "\n", "}", "\n\n", "// Since it's possible to block on send and more requests might be", "// added by the caller while resending, make a copy of all of the", "// requests that need to be resent now and work from the copy. This", "// also allows the lock to be released quickly.", "c", ".", "requestLock", ".", "Lock", "(", ")", "\n", "resendReqs", ":=", "make", "(", "[", "]", "*", "jsonRequest", ",", "0", ",", "c", ".", "requestList", ".", "Len", "(", ")", ")", "\n", "var", "nextElem", "*", "list", ".", "Element", "\n", "for", "e", ":=", "c", ".", "requestList", ".", "Front", "(", ")", ";", "e", "!=", "nil", ";", "e", "=", "nextElem", "{", "nextElem", "=", "e", ".", "Next", "(", ")", "\n\n", "jReq", ":=", "e", ".", "Value", ".", "(", "*", "jsonRequest", ")", "\n", "if", "_", ",", "ok", ":=", "ignoreResends", "[", "jReq", ".", "method", "]", ";", "ok", "{", "// If a request is not sent on reconnect, remove it", "// from the request structures, since no reply is", "// expected.", "delete", "(", "c", ".", "requestMap", ",", "jReq", ".", "id", ")", "\n", "c", ".", "requestList", ".", "Remove", "(", "e", ")", "\n", "}", "else", "{", "resendReqs", "=", "append", "(", "resendReqs", ",", "jReq", ")", "\n", "}", "\n", "}", "\n", "c", ".", "requestLock", ".", "Unlock", "(", ")", "\n\n", "for", "_", ",", "jReq", ":=", "range", "resendReqs", "{", "// Stop resending commands if the client disconnected again", "// since the next reconnect will handle them.", "if", "c", ".", "Disconnected", "(", ")", "{", "return", "\n", "}", "\n\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "jReq", ".", "method", ",", "jReq", ".", "id", ")", "\n", "c", ".", "sendMessage", "(", "jReq", ".", "marshalledJSON", ")", "\n", "}", "\n", "}" ]

[ "resendRequests", "resends", "any", "requests", "that", "had", "not", "completed", "when", "the", "client", "disconnected", ".", "It", "is", "intended", "to", "be", "called", "once", "the", "client", "has", "reconnected", "as", "a", "separate", "goroutine", "." ]

[ "func", "(", "c", "*", "Client", ")", "handleSendPostMessage", "(", "details", "*", "sendPostDetails", ")", "{", "jReq", ":=", "details", ".", "jsonRequest", "\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "jReq", ".", "method", ",", "jReq", ".", "id", ")", "\n", "httpResponse", ",", "err", ":=", "c", ".", "httpClient", ".", "Do", "(", "details", ".", "httpRequest", ")", "\n", "if", "err", "!=", "nil", "{", "jReq", ".", "responseChan", "<-", "&", "response", "{", "err", ":", "err", "}", "\n", "return", "\n", "}", "\n\n", "// Read the raw bytes and close the response.", "respBytes", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "httpResponse", ".", "Body", ")", "\n", "httpResponse", ".", "Body", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "jReq", ".", "responseChan", "<-", "&", "response", "{", "err", ":", "err", "}", "\n", "return", "\n", "}", "\n\n", "// Try to unmarshal the response as a regular JSON-RPC response.", "var", "resp", "rawResponse", "\n", "err", "=", "json", ".", "Unmarshal", "(", "respBytes", ",", "&", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "// When the response itself isn't a valid JSON-RPC response", "// return an error which includes the HTTP status code and raw", "// response bytes.", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "httpResponse", ".", "StatusCode", ",", "string", "(", "respBytes", ")", ")", "\n", "jReq", ".", "responseChan", "<-", "&", "response", "{", "err", ":", "err", "}", "\n", "return", "\n", "}", "\n\n", "res", ",", "err", ":=", "resp", ".", "result", "(", ")", "\n", "jReq", ".", "responseChan", "<-", "&", "response", "{", "result", ":", "res", ",", "err", ":", "err", "}", "\n", "}" ]

[ "handleSendPostMessage", "handles", "performing", "the", "passed", "HTTP", "request", "reading", "the", "result", "unmarshalling", "it", "and", "delivering", "the", "unmarshalled", "result", "to", "the", "provided", "response", "channel", "." ]

[ "func", "(", "c", "*", "Client", ")", "sendPostHandler", "(", ")", "{", "out", ":", "for", "{", "// Send any messages ready for send until the shutdown channel", "// is closed.", "select", "{", "case", "details", ":=", "<-", "c", ".", "sendPostChan", ":", "c", ".", "handleSendPostMessage", "(", "details", ")", "\n\n", "case", "<-", "c", ".", "shutdown", ":", "break", "out", "\n", "}", "\n", "}", "\n\n", "// Drain any wait channels before exiting so nothing is left waiting", "// around to send.", "cleanup", ":", "for", "{", "select", "{", "case", "details", ":=", "<-", "c", ".", "sendPostChan", ":", "details", ".", "jsonRequest", ".", "responseChan", "<-", "&", "response", "{", "result", ":", "nil", ",", "err", ":", "ErrClientShutdown", ",", "}", "\n\n", "default", ":", "break", "cleanup", "\n", "}", "\n", "}", "\n", "c", ".", "wg", ".", "Done", "(", ")", "\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "c", ".", "config", ".", "Host", ")", "\n\n", "}" ]

[ "sendPostHandler", "handles", "all", "outgoing", "messages", "when", "the", "client", "is", "running", "in", "HTTP", "POST", "mode", ".", "It", "uses", "a", "buffered", "channel", "to", "serialize", "output", "messages", "while", "allowing", "the", "sender", "to", "continue", "running", "asynchronously", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "c", "*", "Client", ")", "sendPostRequest", "(", "httpReq", "*", "http", ".", "Request", ",", "jReq", "*", "jsonRequest", ")", "{", "// Don't send the message if shutting down.", "select", "{", "case", "<-", "c", ".", "shutdown", ":", "jReq", ".", "responseChan", "<-", "&", "response", "{", "result", ":", "nil", ",", "err", ":", "ErrClientShutdown", "}", "\n", "default", ":", "}", "\n\n", "c", ".", "sendPostChan", "<-", "&", "sendPostDetails", "{", "jsonRequest", ":", "jReq", ",", "httpRequest", ":", "httpReq", ",", "}", "\n", "}" ]

[ "sendPostRequest", "sends", "the", "passed", "HTTP", "request", "to", "the", "RPC", "server", "using", "the", "HTTP", "client", "associated", "with", "the", "client", ".", "It", "is", "backed", "by", "a", "buffered", "channel", "so", "it", "will", "not", "block", "until", "the", "send", "channel", "is", "full", "." ]

[ "func", "newFutureError", "(", "err", "error", ")", "chan", "*", "response", "{", "responseChan", ":=", "make", "(", "chan", "*", "response", ",", "1", ")", "\n", "responseChan", "<-", "&", "response", "{", "err", ":", "err", "}", "\n", "return", "responseChan", "\n", "}" ]

[ "newFutureError", "returns", "a", "new", "future", "result", "channel", "that", "already", "has", "the", "passed", "error", "waitin", "on", "the", "channel", "with", "the", "reply", "set", "to", "nil", ".", "This", "is", "useful", "to", "easily", "return", "errors", "from", "the", "various", "Async", "functions", "." ]

[ "func", "receiveFuture", "(", "f", "chan", "*", "response", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Wait for a response on the returned channel.", "r", ":=", "<-", "f", "\n", "return", "r", ".", "result", ",", "r", ".", "err", "\n", "}" ]

[ "receiveFuture", "receives", "from", "the", "passed", "futureResult", "channel", "to", "extract", "a", "reply", "or", "any", "errors", ".", "The", "examined", "errors", "include", "an", "error", "in", "the", "futureResult", "and", "the", "error", "in", "the", "reply", "from", "the", "server", ".", "This", "will", "block", "until", "the", "result", "is", "available", "on", "the", "passed", "channel", "." ]

[ "func", "(", "c", "*", "Client", ")", "sendPost", "(", "jReq", "*", "jsonRequest", ")", "{", "// Generate a request to the configured RPC server.", "protocol", ":=", "\"", "\"", "\n", "if", "!", "c", ".", "config", ".", "DisableTLS", "{", "protocol", "=", "\"", "\"", "\n", "}", "\n", "url", ":=", "protocol", "+", "\"", "\"", "+", "c", ".", "config", ".", "Host", "\n", "bodyReader", ":=", "bytes", ".", "NewReader", "(", "jReq", ".", "marshalledJSON", ")", "\n", "httpReq", ",", "err", ":=", "http", ".", "NewRequest", "(", "\"", "\"", ",", "url", ",", "bodyReader", ")", "\n", "if", "err", "!=", "nil", "{", "jReq", ".", "responseChan", "<-", "&", "response", "{", "result", ":", "nil", ",", "err", ":", "err", "}", "\n", "return", "\n", "}", "\n", "httpReq", ".", "Close", "=", "true", "\n", "httpReq", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "// Configure basic access authorization.", "httpReq", ".", "SetBasicAuth", "(", "c", ".", "config", ".", "User", ",", "c", ".", "config", ".", "Pass", ")", "\n\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "jReq", ".", "method", ",", "jReq", ".", "id", ")", "\n", "c", ".", "sendPostRequest", "(", "httpReq", ",", "jReq", ")", "\n", "}" ]

[ "sendPost", "sends", "the", "passed", "request", "to", "the", "server", "by", "issuing", "an", "HTTP", "POST", "request", "using", "the", "provided", "response", "channel", "for", "the", "reply", ".", "Typically", "a", "new", "connection", "is", "opened", "and", "closed", "for", "each", "command", "when", "using", "this", "method", "however", "the", "underlying", "HTTP", "client", "might", "coalesce", "multiple", "commands", "depending", "on", "several", "factors", "including", "the", "remote", "server", "configuration", "." ]

[ "func", "(", "c", "*", "Client", ")", "sendRequest", "(", "jReq", "*", "jsonRequest", ")", "{", "// Choose which marshal and send function to use depending on whether", "// the client running in HTTP POST mode or not. When running in HTTP", "// POST mode, the command is issued via an HTTP client. Otherwise,", "// the command is issued via the asynchronous websocket channels.", "if", "c", ".", "config", ".", "HTTPPostMode", "{", "c", ".", "sendPost", "(", "jReq", ")", "\n", "return", "\n", "}", "\n\n", "// Check whether the websocket connection has never been established,", "// in which case the handler goroutines are not running.", "select", "{", "case", "<-", "c", ".", "connEstablished", ":", "default", ":", "jReq", ".", "responseChan", "<-", "&", "response", "{", "err", ":", "ErrClientNotConnected", "}", "\n", "return", "\n", "}", "\n\n", "// Add the request to the internal tracking map so the response from the", "// remote server can be properly detected and routed to the response", "// channel. Then send the marshalled request via the websocket", "// connection.", "if", "err", ":=", "c", ".", "addRequest", "(", "jReq", ")", ";", "err", "!=", "nil", "{", "jReq", ".", "responseChan", "<-", "&", "response", "{", "err", ":", "err", "}", "\n", "return", "\n", "}", "\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "jReq", ".", "method", ",", "jReq", ".", "id", ")", "\n", "c", ".", "sendMessage", "(", "jReq", ".", "marshalledJSON", ")", "\n", "}" ]

[ "sendRequest", "sends", "the", "passed", "json", "request", "to", "the", "associated", "server", "using", "the", "provided", "response", "channel", "for", "the", "reply", ".", "It", "handles", "both", "websocket", "and", "HTTP", "POST", "mode", "depending", "on", "the", "configuration", "of", "the", "client", "." ]

[ "func", "(", "c", "*", "Client", ")", "sendCmd", "(", "cmd", "interface", "{", "}", ")", "chan", "*", "response", "{", "// Get the method associated with the command.", "method", ",", "err", ":=", "btcjson", ".", "CmdMethod", "(", "cmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newFutureError", "(", "err", ")", "\n", "}", "\n\n", "// Marshal the command.", "id", ":=", "c", ".", "NextID", "(", ")", "\n", "marshalledJSON", ",", "err", ":=", "btcjson", ".", "MarshalCmd", "(", "id", ",", "cmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newFutureError", "(", "err", ")", "\n", "}", "\n\n", "// Generate the request and send it along with a channel to respond on.", "responseChan", ":=", "make", "(", "chan", "*", "response", ",", "1", ")", "\n", "jReq", ":=", "&", "jsonRequest", "{", "id", ":", "id", ",", "method", ":", "method", ",", "cmd", ":", "cmd", ",", "marshalledJSON", ":", "marshalledJSON", ",", "responseChan", ":", "responseChan", ",", "}", "\n", "c", ".", "sendRequest", "(", "jReq", ")", "\n\n", "return", "responseChan", "\n", "}" ]

[ "sendCmd", "sends", "the", "passed", "command", "to", "the", "associated", "server", "and", "returns", "a", "response", "channel", "on", "which", "the", "reply", "will", "be", "delivered", "at", "some", "point", "in", "the", "future", ".", "It", "handles", "both", "websocket", "and", "HTTP", "POST", "mode", "depending", "on", "the", "configuration", "of", "the", "client", "." ]

[ "func", "(", "c", "*", "Client", ")", "Disconnected", "(", ")", "bool", "{", "c", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mtx", ".", "Unlock", "(", ")", "\n\n", "select", "{", "case", "<-", "c", ".", "connEstablished", ":", "return", "c", ".", "disconnected", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "Disconnected", "returns", "whether", "or", "not", "the", "server", "is", "disconnected", ".", "If", "a", "websocket", "client", "was", "created", "but", "never", "connected", "this", "also", "returns", "false", "." ]

[ "func", "(", "c", "*", "Client", ")", "doDisconnect", "(", ")", "bool", "{", "if", "c", ".", "config", ".", "HTTPPostMode", "{", "return", "false", "\n", "}", "\n\n", "c", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mtx", ".", "Unlock", "(", ")", "\n\n", "// Nothing to do if already disconnected.", "if", "c", ".", "disconnected", "{", "return", "false", "\n", "}", "\n\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "c", ".", "config", ".", "Host", ")", "\n", "close", "(", "c", ".", "disconnect", ")", "\n", "if", "c", ".", "wsConn", "!=", "nil", "{", "c", ".", "wsConn", ".", "Close", "(", ")", "\n", "}", "\n", "c", ".", "disconnected", "=", "true", "\n", "return", "true", "\n", "}" ]

[ "doDisconnect", "disconnects", "the", "websocket", "associated", "with", "the", "client", "if", "it", "hasn", "t", "already", "been", "disconnected", ".", "It", "will", "return", "false", "if", "the", "disconnect", "is", "not", "needed", "or", "the", "client", "is", "running", "in", "HTTP", "POST", "mode", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "c", "*", "Client", ")", "doShutdown", "(", ")", "bool", "{", "// Ignore the shutdown request if the client is already in the process", "// of shutting down or already shutdown.", "select", "{", "case", "<-", "c", ".", "shutdown", ":", "return", "false", "\n", "default", ":", "}", "\n\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "c", ".", "config", ".", "Host", ")", "\n", "close", "(", "c", ".", "shutdown", ")", "\n", "return", "true", "\n", "}" ]

[ "doShutdown", "closes", "the", "shutdown", "channel", "and", "logs", "the", "shutdown", "unless", "shutdown", "is", "already", "in", "progress", ".", "It", "will", "return", "false", "if", "the", "shutdown", "is", "not", "needed", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "c", "*", "Client", ")", "Disconnect", "(", ")", "{", "// Nothing to do if already disconnected or running in HTTP POST mode.", "if", "!", "c", ".", "doDisconnect", "(", ")", "{", "return", "\n", "}", "\n\n", "c", ".", "requestLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "requestLock", ".", "Unlock", "(", ")", "\n\n", "// When operating without auto reconnect, send errors to any pending", "// requests and shutdown the client.", "if", "c", ".", "config", ".", "DisableAutoReconnect", "{", "for", "e", ":=", "c", ".", "requestList", ".", "Front", "(", ")", ";", "e", "!=", "nil", ";", "e", "=", "e", ".", "Next", "(", ")", "{", "req", ":=", "e", ".", "Value", ".", "(", "*", "jsonRequest", ")", "\n", "req", ".", "responseChan", "<-", "&", "response", "{", "result", ":", "nil", ",", "err", ":", "ErrClientDisconnect", ",", "}", "\n", "}", "\n", "c", ".", "removeAllRequests", "(", ")", "\n", "c", ".", "doShutdown", "(", ")", "\n", "}", "\n", "}" ]

[ "Disconnect", "disconnects", "the", "current", "websocket", "associated", "with", "the", "client", ".", "The", "connection", "will", "automatically", "be", "re", "-", "established", "unless", "the", "client", "was", "created", "with", "the", "DisableAutoReconnect", "flag", ".", "This", "function", "has", "no", "effect", "when", "the", "client", "is", "running", "in", "HTTP", "POST", "mode", "." ]

[ "func", "(", "c", "*", "Client", ")", "Shutdown", "(", ")", "{", "// Do the shutdown under the request lock to prevent clients from", "// adding new requests while the client shutdown process is initiated.", "c", ".", "requestLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "requestLock", ".", "Unlock", "(", ")", "\n\n", "// Ignore the shutdown request if the client is already in the process", "// of shutting down or already shutdown.", "if", "!", "c", ".", "doShutdown", "(", ")", "{", "return", "\n", "}", "\n\n", "// Send the ErrClientShutdown error to any pending requests.", "for", "e", ":=", "c", ".", "requestList", ".", "Front", "(", ")", ";", "e", "!=", "nil", ";", "e", "=", "e", ".", "Next", "(", ")", "{", "req", ":=", "e", ".", "Value", ".", "(", "*", "jsonRequest", ")", "\n", "req", ".", "responseChan", "<-", "&", "response", "{", "result", ":", "nil", ",", "err", ":", "ErrClientShutdown", ",", "}", "\n", "}", "\n", "c", ".", "removeAllRequests", "(", ")", "\n\n", "// Disconnect the client if needed.", "c", ".", "doDisconnect", "(", ")", "\n", "}" ]

[ "Shutdown", "shuts", "down", "the", "client", "by", "disconnecting", "any", "connections", "associated", "with", "the", "client", "and", "when", "automatic", "reconnect", "is", "enabled", "preventing", "future", "attempts", "to", "reconnect", ".", "It", "also", "stops", "all", "goroutines", "." ]

[ "func", "newHTTPClient", "(", "config", "*", "ConnConfig", ")", "(", "*", "http", ".", "Client", ",", "error", ")", "{", "// Set proxy function if there is a proxy configured.", "var", "proxyFunc", "func", "(", "*", "http", ".", "Request", ")", "(", "*", "url", ".", "URL", ",", "error", ")", "\n", "if", "config", ".", "Proxy", "!=", "\"", "\"", "{", "proxyURL", ",", "err", ":=", "url", ".", "Parse", "(", "config", ".", "Proxy", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "proxyFunc", "=", "http", ".", "ProxyURL", "(", "proxyURL", ")", "\n", "}", "\n\n", "// Configure TLS if needed.", "var", "tlsConfig", "*", "tls", ".", "Config", "\n", "if", "!", "config", ".", "DisableTLS", "{", "if", "len", "(", "config", ".", "Certificates", ")", ">", "0", "{", "pool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n", "pool", ".", "AppendCertsFromPEM", "(", "config", ".", "Certificates", ")", "\n", "tlsConfig", "=", "&", "tls", ".", "Config", "{", "RootCAs", ":", "pool", ",", "}", "\n", "}", "\n", "}", "\n\n", "client", ":=", "http", ".", "Client", "{", "Transport", ":", "&", "http", ".", "Transport", "{", "Proxy", ":", "proxyFunc", ",", "TLSClientConfig", ":", "tlsConfig", ",", "}", ",", "}", "\n\n", "return", "&", "client", ",", "nil", "\n", "}" ]

[ "newHTTPClient", "returns", "a", "new", "http", "client", "that", "is", "configured", "according", "to", "the", "proxy", "and", "TLS", "settings", "in", "the", "associated", "connection", "configuration", "." ]

[ "func", "dial", "(", "config", "*", "ConnConfig", ")", "(", "*", "websocket", ".", "Conn", ",", "error", ")", "{", "// Setup TLS if not disabled.", "var", "tlsConfig", "*", "tls", ".", "Config", "\n", "var", "scheme", "=", "\"", "\"", "\n", "if", "!", "config", ".", "DisableTLS", "{", "tlsConfig", "=", "&", "tls", ".", "Config", "{", "MinVersion", ":", "tls", ".", "VersionTLS12", ",", "}", "\n", "if", "len", "(", "config", ".", "Certificates", ")", ">", "0", "{", "pool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n", "pool", ".", "AppendCertsFromPEM", "(", "config", ".", "Certificates", ")", "\n", "tlsConfig", ".", "RootCAs", "=", "pool", "\n", "}", "\n", "scheme", "=", "\"", "\"", "\n", "}", "\n\n", "// Create a websocket dialer that will be used to make the connection.", "// It is modified by the proxy setting below as needed.", "dialer", ":=", "websocket", ".", "Dialer", "{", "TLSClientConfig", ":", "tlsConfig", "}", "\n\n", "// Setup the proxy if one is configured.", "if", "config", ".", "Proxy", "!=", "\"", "\"", "{", "proxy", ":=", "&", "socks", ".", "Proxy", "{", "Addr", ":", "config", ".", "Proxy", ",", "Username", ":", "config", ".", "ProxyUser", ",", "Password", ":", "config", ".", "ProxyPass", ",", "}", "\n", "dialer", ".", "NetDial", "=", "proxy", ".", "Dial", "\n", "}", "\n\n", "// The RPC server requires basic authorization, so create a custom", "// request header with the Authorization header set.", "login", ":=", "config", ".", "User", "+", "\"", "\"", "+", "config", ".", "Pass", "\n", "auth", ":=", "\"", "\"", "+", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "[", "]", "byte", "(", "login", ")", ")", "\n", "requestHeader", ":=", "make", "(", "http", ".", "Header", ")", "\n", "requestHeader", ".", "Add", "(", "\"", "\"", ",", "auth", ")", "\n\n", "// Dial the connection.", "url", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scheme", ",", "config", ".", "Host", ",", "config", ".", "Endpoint", ")", "\n", "wsConn", ",", "resp", ",", "err", ":=", "dialer", ".", "Dial", "(", "url", ",", "requestHeader", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "!=", "websocket", ".", "ErrBadHandshake", "||", "resp", "==", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Detect HTTP authentication error status codes.", "if", "resp", ".", "StatusCode", "==", "http", ".", "StatusUnauthorized", "||", "resp", ".", "StatusCode", "==", "http", ".", "StatusForbidden", "{", "return", "nil", ",", "ErrInvalidAuth", "\n", "}", "\n\n", "// The connection was authenticated and the status response was", "// ok, but the websocket handshake still failed, so the endpoint", "// is invalid in some way.", "if", "resp", ".", "StatusCode", "==", "http", ".", "StatusOK", "{", "return", "nil", ",", "ErrInvalidEndpoint", "\n", "}", "\n\n", "// Return the status text from the server if none of the special", "// cases above apply.", "return", "nil", ",", "errors", ".", "New", "(", "resp", ".", "Status", ")", "\n", "}", "\n", "return", "wsConn", ",", "nil", "\n", "}" ]

[ "dial", "opens", "a", "websocket", "connection", "using", "the", "passed", "connection", "configuration", "details", "." ]

[ "func", "New", "(", "config", "*", "ConnConfig", ",", "ntfnHandlers", "*", "NotificationHandlers", ")", "(", "*", "Client", ",", "error", ")", "{", "// Either open a websocket connection or create an HTTP client depending", "// on the HTTP POST mode. Also, set the notification handlers to nil", "// when running in HTTP POST mode.", "var", "wsConn", "*", "websocket", ".", "Conn", "\n", "var", "httpClient", "*", "http", ".", "Client", "\n", "connEstablished", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "var", "start", "bool", "\n", "if", "config", ".", "HTTPPostMode", "{", "ntfnHandlers", "=", "nil", "\n", "start", "=", "true", "\n\n", "var", "err", "error", "\n", "httpClient", ",", "err", "=", "newHTTPClient", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "else", "{", "if", "!", "config", ".", "DisableConnectOnNew", "{", "var", "err", "error", "\n", "wsConn", ",", "err", "=", "dial", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "start", "=", "true", "\n", "}", "\n", "}", "\n\n", "client", ":=", "&", "Client", "{", "config", ":", "config", ",", "wsConn", ":", "wsConn", ",", "httpClient", ":", "httpClient", ",", "requestMap", ":", "make", "(", "map", "[", "uint64", "]", "*", "list", ".", "Element", ")", ",", "requestList", ":", "list", ".", "New", "(", ")", ",", "ntfnHandlers", ":", "ntfnHandlers", ",", "ntfnState", ":", "newNotificationState", "(", ")", ",", "sendChan", ":", "make", "(", "chan", "[", "]", "byte", ",", "sendBufferSize", ")", ",", "sendPostChan", ":", "make", "(", "chan", "*", "sendPostDetails", ",", "sendPostBufferSize", ")", ",", "connEstablished", ":", "connEstablished", ",", "disconnect", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "shutdown", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n\n", "if", "start", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "config", ".", "Host", ")", "\n", "close", "(", "connEstablished", ")", "\n", "client", ".", "start", "(", ")", "\n", "if", "!", "client", ".", "config", ".", "HTTPPostMode", "&&", "!", "client", ".", "config", ".", "DisableAutoReconnect", "{", "client", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "client", ".", "wsReconnectHandler", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "client", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "new", "RPC", "client", "based", "on", "the", "provided", "connection", "configuration", "details", ".", "The", "notification", "handlers", "parameter", "may", "be", "nil", "if", "you", "are", "not", "interested", "in", "receiving", "notifications", "and", "will", "be", "ignored", "if", "the", "configuration", "is", "set", "to", "run", "in", "HTTP", "POST", "mode", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetBestBlockHashAsync", "(", ")", "FutureGetBestBlockHashResult", "{", "cmd", ":=", "btcjson", ".", "NewGetBestBlockHashCmd", "(", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetBestBlockHashAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetBestBlockHash", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "r", "FutureGetBlockResult", ")", "Receive", "(", ")", "(", "*", "wire", ".", "MsgBlock", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as a string.", "var", "blockHex", "string", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "blockHex", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Decode the serialized block hex to raw bytes.", "serializedBlock", ",", "err", ":=", "hex", ".", "DecodeString", "(", "blockHex", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Deserialize the block and return it.", "var", "msgBlock", "wire", ".", "MsgBlock", "\n", "err", "=", "msgBlock", ".", "Deserialize", "(", "bytes", ".", "NewReader", "(", "serializedBlock", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "msgBlock", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "raw", "block", "requested", "from", "the", "server", "given", "its", "hash", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetBlockAsync", "(", "blockHash", "*", "chainhash", ".", "Hash", ")", "FutureGetBlockResult", "{", "hash", ":=", "\"", "\"", "\n", "if", "blockHash", "!=", "nil", "{", "hash", "=", "blockHash", ".", "String", "(", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewGetBlockCmd", "(", "hash", ",", "btcjson", ".", "Bool", "(", "false", ")", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetBlockAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetBlock", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetBlock", "(", "blockHash", "*", "chainhash", ".", "Hash", ")", "(", "*", "wire", ".", "MsgBlock", ",", "error", ")", "{", "return", "c", ".", "GetBlockAsync", "(", "blockHash", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetBlock", "returns", "a", "raw", "block", "from", "the", "server", "given", "its", "hash", ".", "See", "GetBlockVerbose", "to", "retrieve", "a", "data", "structure", "with", "information", "about", "the", "block", "instead", "." ]

[ "func", "(", "r", "FutureGetBlockVerboseResult", ")", "Receive", "(", ")", "(", "*", "btcjson", ".", "GetBlockVerboseResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal the raw result into a BlockResult.", "var", "blockResult", "btcjson", ".", "GetBlockVerboseResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "blockResult", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "blockResult", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "data", "structure", "from", "the", "server", "with", "information", "about", "the", "requested", "block", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetBlockVerbose", "(", "blockHash", "*", "chainhash", ".", "Hash", ")", "(", "*", "btcjson", ".", "GetBlockVerboseResult", ",", "error", ")", "{", "return", "c", ".", "GetBlockVerboseAsync", "(", "blockHash", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetBlockVerbose", "returns", "a", "data", "structure", "from", "the", "server", "with", "information", "about", "a", "block", "given", "its", "hash", ".", "See", "GetBlockVerboseTx", "to", "retrieve", "transaction", "data", "structures", "as", "well", ".", "See", "GetBlock", "to", "retrieve", "a", "raw", "block", "instead", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetBlockVerboseTxAsync", "(", "blockHash", "*", "chainhash", ".", "Hash", ")", "FutureGetBlockVerboseResult", "{", "hash", ":=", "\"", "\"", "\n", "if", "blockHash", "!=", "nil", "{", "hash", "=", "blockHash", ".", "String", "(", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewGetBlockCmd", "(", "hash", ",", "btcjson", ".", "Bool", "(", "true", ")", ",", "btcjson", ".", "Bool", "(", "true", ")", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetBlockVerboseTxAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetBlockVerboseTx", "or", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetBlockVerboseTx", "(", "blockHash", "*", "chainhash", ".", "Hash", ")", "(", "*", "btcjson", ".", "GetBlockVerboseResult", ",", "error", ")", "{", "return", "c", ".", "GetBlockVerboseTxAsync", "(", "blockHash", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetBlockVerboseTx", "returns", "a", "data", "structure", "from", "the", "server", "with", "information", "about", "a", "block", "and", "its", "transactions", "given", "its", "hash", ".", "See", "GetBlockVerbose", "if", "only", "transaction", "hashes", "are", "preferred", ".", "See", "GetBlock", "to", "retrieve", "a", "raw", "block", "instead", "." ]

[ "func", "(", "r", "FutureGetBlockCountResult", ")", "Receive", "(", ")", "(", "int64", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "// Unmarshal the result as an int64.", "var", "count", "int64", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "count", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "count", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "number", "of", "blocks", "in", "the", "longest", "block", "chain", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetBlockCountAsync", "(", ")", "FutureGetBlockCountResult", "{", "cmd", ":=", "btcjson", ".", "NewGetBlockCountCmd", "(", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetBlockCountAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetBlockCount", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "r", "FutureGetDifficultyResult", ")", "Receive", "(", ")", "(", "float64", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "// Unmarshal the result as a float64.", "var", "difficulty", "float64", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "difficulty", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "difficulty", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "proof", "-", "of", "-", "work", "difficulty", "as", "a", "multiple", "of", "the", "minimum", "difficulty", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetDifficultyAsync", "(", ")", "FutureGetDifficultyResult", "{", "cmd", ":=", "btcjson", ".", "NewGetDifficultyCmd", "(", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetDifficultyAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetDifficulty", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "r", "FutureGetBlockChainInfoResult", ")", "Receive", "(", ")", "(", "*", "btcjson", ".", "GetBlockChainInfoResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "chainInfo", "btcjson", ".", "GetBlockChainInfoResult", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "res", ",", "&", "chainInfo", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "chainInfo", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "chain", "info", "result", "provided", "by", "the", "server", "." ]