Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "SetLogOut", "(", "log", "*", "logrus", ".", "Logger", ",", "outString", "string", ")", "error", "{", "switch", "outString", "{", "case", "\"", "\"", ":", "log", ".", "Out", "=", "os", ".", "Stdout", "\n", "case", "\"", "\"", ":", "log", ".", "Out", "=", "os", ".", "Stderr", "\n", "default", ":", "f", ",", "err", ":=", "os", ".", "OpenFile", "(", "outString", ",", "os", ".", "O_RDWR", "|", "os", ".", "O_CREATE", "|", "os", ".", "O_APPEND", ",", "0644", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "log", ".", "Out", "=", "f", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SetLogOut", "provide", "log", "stdout", "and", "stderr", "output" ]

[ "func", "LogRequest", "(", "uri", "string", ",", "method", "string", ",", "ip", "string", ",", "contentType", "string", ",", "agent", "string", ")", "{", "var", "output", "string", "\n", "log", ":=", "&", "LogReq", "{", "URI", ":", "uri", ",", "Method", ":", "method", ",", "IP", ":", "ip", ",", "ContentType", ":", "contentType", ",", "Agent", ":", "agent", ",", "}", "\n\n", "if", "PushConf", ".", "Log", ".", "Format", "==", "\"", "\"", "{", "logJSON", ",", "_", ":=", "json", ".", "Marshal", "(", "log", ")", "\n\n", "output", "=", "string", "(", "logJSON", ")", "\n", "}", "else", "{", "var", "headerColor", ",", "resetColor", "string", "\n\n", "if", "isTerm", "{", "headerColor", "=", "magenta", "\n", "resetColor", "=", "reset", "\n", "}", "\n\n", "// format is string", "output", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "headerColor", ",", "resetColor", ",", "log", ".", "Method", ",", "log", ".", "URI", ",", "log", ".", "IP", ",", "log", ".", "ContentType", ",", "log", ".", "Agent", ",", ")", "\n", "}", "\n\n", "LogAccess", ".", "Info", "(", "output", ")", "\n", "}" ]

[ "LogRequest", "record", "http", "request" ]

[ "func", "LogPush", "(", "status", ",", "token", "string", ",", "req", "PushNotification", ",", "errPush", "error", ")", "{", "var", "platColor", ",", "resetColor", ",", "output", "string", "\n\n", "if", "isTerm", "{", "platColor", "=", "colorForPlatForm", "(", "req", ".", "Platform", ")", "\n", "resetColor", "=", "reset", "\n", "}", "\n\n", "log", ":=", "getLogPushEntry", "(", "status", ",", "token", ",", "req", ",", "errPush", ")", "\n\n", "if", "PushConf", ".", "Log", ".", "Format", "==", "\"", "\"", "{", "logJSON", ",", "_", ":=", "json", ".", "Marshal", "(", "log", ")", "\n\n", "output", "=", "string", "(", "logJSON", ")", "\n", "}", "else", "{", "var", "typeColor", "string", "\n", "switch", "status", "{", "case", "SucceededPush", ":", "if", "isTerm", "{", "typeColor", "=", "green", "\n", "}", "\n\n", "output", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeColor", ",", "log", ".", "Type", ",", "resetColor", ",", "platColor", ",", "log", ".", "Platform", ",", "resetColor", ",", "log", ".", "Token", ",", "log", ".", "Message", ",", ")", "\n", "case", "FailedPush", ":", "if", "isTerm", "{", "typeColor", "=", "red", "\n", "}", "\n\n", "output", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeColor", ",", "log", ".", "Type", ",", "resetColor", ",", "platColor", ",", "log", ".", "Platform", ",", "resetColor", ",", "log", ".", "Token", ",", "log", ".", "Message", ",", "log", ".", "Error", ",", ")", "\n", "}", "\n", "}", "\n\n", "switch", "status", "{", "case", "SucceededPush", ":", "LogAccess", ".", "Info", "(", "output", ")", "\n", "case", "FailedPush", ":", "LogError", ".", "Error", "(", "output", ")", "\n", "}", "\n", "}" ]

[ "LogPush", "record", "user", "push", "request", "and", "server", "response", "." ]

[ "func", "LogMiddleware", "(", ")", "gin", ".", "HandlerFunc", "{", "return", "func", "(", "c", "*", "gin", ".", "Context", ")", "{", "LogRequest", "(", "c", ".", "Request", ".", "URL", ".", "Path", ",", "c", ".", "Request", ".", "Method", ",", "c", ".", "ClientIP", "(", ")", ",", "c", ".", "ContentType", "(", ")", ",", "c", ".", "GetHeader", "(", "\"", "\"", ")", ")", "\n", "c", ".", "Next", "(", ")", "\n", "}", "\n", "}" ]

[ "LogMiddleware", "provide", "gin", "router", "handler", "." ]

[ "func", "InitWorkers", "(", "workerNum", "int64", ",", "queueNum", "int64", ")", "{", "LogAccess", ".", "Debug", "(", "\"", "\"", ",", "workerNum", ",", "\"", "\"", ",", "queueNum", ")", "\n", "QueueNotification", "=", "make", "(", "chan", "PushNotification", ",", "queueNum", ")", "\n", "for", "i", ":=", "int64", "(", "0", ")", ";", "i", "<", "workerNum", ";", "i", "++", "{", "go", "startWorker", "(", ")", "\n", "}", "\n", "}" ]

[ "InitWorkers", "for", "initialize", "all", "workers", "." ]

[ "func", "SendNotification", "(", "msg", "PushNotification", ")", "{", "switch", "msg", ".", "Platform", "{", "case", "PlatFormIos", ":", "PushToIOS", "(", "msg", ")", "\n", "case", "PlatFormAndroid", ":", "PushToAndroid", "(", "msg", ")", "\n", "}", "\n", "}" ]

[ "SendNotification", "is", "send", "message", "to", "iOS", "or", "Android" ]

[ "func", "queueNotification", "(", "req", "RequestPush", ")", "(", "int", ",", "[", "]", "LogPushEntry", ")", "{", "var", "count", "int", "\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "newNotification", ":=", "[", "]", "*", "PushNotification", "{", "}", "\n", "for", "i", ":=", "range", "req", ".", "Notifications", "{", "notification", ":=", "&", "req", ".", "Notifications", "[", "i", "]", "\n", "switch", "notification", ".", "Platform", "{", "case", "PlatFormIos", ":", "if", "!", "PushConf", ".", "Ios", ".", "Enabled", "{", "continue", "\n", "}", "\n", "case", "PlatFormAndroid", ":", "if", "!", "PushConf", ".", "Android", ".", "Enabled", "{", "continue", "\n", "}", "\n", "}", "\n", "newNotification", "=", "append", "(", "newNotification", ",", "notification", ")", "\n", "}", "\n\n", "log", ":=", "make", "(", "[", "]", "LogPushEntry", ",", "0", ",", "count", ")", "\n", "for", "_", ",", "notification", ":=", "range", "newNotification", "{", "if", "PushConf", ".", "Core", ".", "Sync", "{", "notification", ".", "wg", "=", "&", "wg", "\n", "notification", ".", "log", "=", "&", "log", "\n", "notification", ".", "AddWaitCount", "(", ")", "\n", "}", "\n", "if", "!", "tryEnqueue", "(", "*", "notification", ",", "QueueNotification", ")", "{", "LogError", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n", "count", "+=", "len", "(", "notification", ".", "Tokens", ")", "\n", "// Count topic message", "if", "notification", ".", "To", "!=", "\"", "\"", "{", "count", "++", "\n", "}", "\n", "}", "\n\n", "if", "PushConf", ".", "Core", ".", "Sync", "{", "wg", ".", "Wait", "(", ")", "\n", "}", "\n\n", "StatStorage", ".", "AddTotalCount", "(", "int64", "(", "count", ")", ")", "\n\n", "return", "count", ",", "log", "\n", "}" ]

[ "queueNotification", "add", "notification", "to", "queue", "list", "." ]

[ "func", "tryEnqueue", "(", "job", "PushNotification", ",", "jobChan", "chan", "<-", "PushNotification", ")", "bool", "{", "select", "{", "case", "jobChan", "<-", "job", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "tryEnqueue", "tries", "to", "enqueue", "a", "job", "to", "the", "given", "job", "channel", ".", "Returns", "true", "if", "the", "operation", "was", "successful", "and", "false", "if", "enqueuing", "would", "not", "have", "been", "possible", "without", "blocking", ".", "Job", "is", "not", "enqueued", "in", "the", "latter", "case", "." ]

[ "func", "(", "msg", "*", "MsgCFHeaders", ")", "AddCFHash", "(", "hash", "*", "chainhash", ".", "Hash", ")", "error", "{", "if", "len", "(", "msg", ".", "FilterHashes", ")", "+", "1", ">", "MaxCFHeadersPerMsg", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "MaxBlockHeadersPerMsg", ")", "\n", "return", "messageError", "(", "\"", "\"", ",", "str", ")", "\n", "}", "\n\n", "msg", ".", "FilterHashes", "=", "append", "(", "msg", ".", "FilterHashes", ",", "hash", ")", "\n", "return", "nil", "\n", "}" ]

[ "AddCFHash", "adds", "a", "new", "filter", "hash", "to", "the", "message", "." ]

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

[ "Deserialize", "decodes", "a", "filter", "header", "from", "r", "into", "the", "receiver", "using", "a", "format", "that", "is", "suitable", "for", "long", "-", "term", "storage", "such", "as", "a", "database", ".", "This", "function", "differs", "from", "BtcDecode", "in", "that", "BtcDecode", "decodes", "from", "the", "bitcoin", "wire", "protocol", "as", "it", "was", "sent", "across", "the", "network", ".", "The", "wire", "encoding", "can", "technically", "differ", "depending", "on", "the", "protocol", "version", "and", "doesn", "t", "even", "really", "need", "to", "match", "the", "format", "of", "a", "stored", "filter", "header", "at", "all", ".", "As", "of", "the", "time", "this", "comment", "was", "written", "the", "encoded", "filter", "header", "is", "the", "same", "in", "both", "instances", "but", "there", "is", "a", "distinct", "difference", "and", "separating", "the", "two", "allows", "the", "API", "to", "be", "flexible", "enough", "to", "deal", "with", "changes", "." ]

[ "func", "checkMinimalDataEncoding", "(", "v", "[", "]", "byte", ")", "error", "{", "if", "len", "(", "v", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Check that the number is encoded with the minimum possible", "// number of bytes.", "//", "// If the most-significant-byte - excluding the sign bit - is zero", "// then we're not minimal. Note how this test also rejects the", "// negative-zero encoding, [0x80].", "if", "v", "[", "len", "(", "v", ")", "-", "1", "]", "&", "0x7f", "==", "0", "{", "// One exception: if there's more than one byte and the most", "// significant bit of the second-most-significant-byte is set", "// it would conflict with the sign bit. An example of this case", "// is +-255, which encode to 0xff00 and 0xff80 respectively.", "// (big-endian).", "if", "len", "(", "v", ")", "==", "1", "||", "v", "[", "len", "(", "v", ")", "-", "2", "]", "&", "0x80", "==", "0", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "v", ")", "\n", "return", "scriptError", "(", "ErrMinimalData", ",", "str", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkMinimalDataEncoding", "returns", "whether", "or", "not", "the", "passed", "byte", "array", "adheres", "to", "the", "minimal", "encoding", "requirements", "." ]

[ "func", "(", "n", "scriptNum", ")", "Int32", "(", ")", "int32", "{", "if", "n", ">", "maxInt32", "{", "return", "maxInt32", "\n", "}", "\n\n", "if", "n", "<", "minInt32", "{", "return", "minInt32", "\n", "}", "\n\n", "return", "int32", "(", "n", ")", "\n", "}" ]

[ "Int32", "returns", "the", "script", "number", "clamped", "to", "a", "valid", "int32", ".", "That", "is", "to", "say", "when", "the", "script", "number", "is", "higher", "than", "the", "max", "allowed", "int32", "the", "max", "int32", "value", "is", "returned", "and", "vice", "versa", "for", "the", "minimum", "value", ".", "Note", "that", "this", "behavior", "is", "different", "from", "a", "simple", "int32", "cast", "because", "that", "truncates", "and", "the", "consensus", "rules", "dictate", "numbers", "which", "are", "directly", "cast", "to", "ints", "provide", "this", "behavior", ".", "In", "practice", "for", "most", "opcodes", "the", "number", "should", "never", "be", "out", "of", "range", "since", "it", "will", "have", "been", "created", "with", "makeScriptNum", "using", "the", "defaultScriptLen", "value", "which", "rejects", "them", ".", "In", "case", "something", "in", "the", "future", "ends", "up", "calling", "this", "function", "against", "the", "result", "of", "some", "arithmetic", "which", "IS", "allowed", "to", "be", "out", "of", "range", "before", "being", "reinterpreted", "as", "an", "integer", "this", "will", "provide", "the", "correct", "behavior", "." ]

[ "func", "putVLQ", "(", "target", "[", "]", "byte", ",", "n", "uint64", ")", "int", "{", "offset", ":=", "0", "\n", "for", ";", ";", "offset", "++", "{", "// The high bit is set when another byte follows.", "highBitMask", ":=", "byte", "(", "0x80", ")", "\n", "if", "offset", "==", "0", "{", "highBitMask", "=", "0x00", "\n", "}", "\n\n", "target", "[", "offset", "]", "=", "byte", "(", "n", "&", "0x7f", ")", "|", "highBitMask", "\n", "if", "n", "<=", "0x7f", "{", "break", "\n", "}", "\n", "n", "=", "(", "n", ">>", "7", ")", "-", "1", "\n", "}", "\n\n", "// Reverse the bytes so it is MSB-encoded.", "for", "i", ",", "j", ":=", "0", ",", "offset", ";", "i", "<", "j", ";", "i", ",", "j", "=", "i", "+", "1", ",", "j", "-", "1", "{", "target", "[", "i", "]", ",", "target", "[", "j", "]", "=", "target", "[", "j", "]", ",", "target", "[", "i", "]", "\n", "}", "\n\n", "return", "offset", "+", "1", "\n", "}" ]

[ "putVLQ", "serializes", "the", "provided", "number", "to", "a", "variable", "-", "length", "quantity", "according", "to", "the", "format", "described", "above", "and", "returns", "the", "number", "of", "bytes", "of", "the", "encoded", "value", ".", "The", "result", "is", "placed", "directly", "into", "the", "passed", "byte", "slice", "which", "must", "be", "at", "least", "large", "enough", "to", "handle", "the", "number", "of", "bytes", "returned", "by", "the", "serializeSizeVLQ", "function", "or", "it", "will", "panic", "." ]

[ "func", "deserializeVLQ", "(", "serialized", "[", "]", "byte", ")", "(", "uint64", ",", "int", ")", "{", "var", "n", "uint64", "\n", "var", "size", "int", "\n", "for", "_", ",", "val", ":=", "range", "serialized", "{", "size", "++", "\n", "n", "=", "(", "n", "<<", "7", ")", "|", "uint64", "(", "val", "&", "0x7f", ")", "\n", "if", "val", "&", "0x80", "!=", "0x80", "{", "break", "\n", "}", "\n", "n", "++", "\n", "}", "\n\n", "return", "n", ",", "size", "\n", "}" ]

[ "deserializeVLQ", "deserializes", "the", "provided", "variable", "-", "length", "quantity", "according", "to", "the", "format", "described", "above", ".", "It", "also", "returns", "the", "number", "of", "bytes", "deserialized", "." ]

[ "func", "isPubKeyHash", "(", "script", "[", "]", "byte", ")", "(", "bool", ",", "[", "]", "byte", ")", "{", "if", "len", "(", "script", ")", "==", "25", "&&", "script", "[", "0", "]", "==", "txscript", ".", "OP_DUP", "&&", "script", "[", "1", "]", "==", "txscript", ".", "OP_HASH160", "&&", "script", "[", "2", "]", "==", "txscript", ".", "OP_DATA_20", "&&", "script", "[", "23", "]", "==", "txscript", ".", "OP_EQUALVERIFY", "&&", "script", "[", "24", "]", "==", "txscript", ".", "OP_CHECKSIG", "{", "return", "true", ",", "script", "[", "3", ":", "23", "]", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "isPubKeyHash", "returns", "whether", "or", "not", "the", "passed", "public", "key", "script", "is", "a", "standard", "pay", "-", "to", "-", "pubkey", "-", "hash", "script", "along", "with", "the", "pubkey", "hash", "it", "is", "paying", "to", "if", "it", "is", "." ]

[ "func", "isScriptHash", "(", "script", "[", "]", "byte", ")", "(", "bool", ",", "[", "]", "byte", ")", "{", "if", "len", "(", "script", ")", "==", "23", "&&", "script", "[", "0", "]", "==", "txscript", ".", "OP_HASH160", "&&", "script", "[", "1", "]", "==", "txscript", ".", "OP_DATA_20", "&&", "script", "[", "22", "]", "==", "txscript", ".", "OP_EQUAL", "{", "return", "true", ",", "script", "[", "2", ":", "22", "]", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "isScriptHash", "returns", "whether", "or", "not", "the", "passed", "public", "key", "script", "is", "a", "standard", "pay", "-", "to", "-", "script", "-", "hash", "script", "along", "with", "the", "script", "hash", "it", "is", "paying", "to", "if", "it", "is", "." ]

[ "func", "compressedScriptSize", "(", "pkScript", "[", "]", "byte", ")", "int", "{", "// Pay-to-pubkey-hash script.", "if", "valid", ",", "_", ":=", "isPubKeyHash", "(", "pkScript", ")", ";", "valid", "{", "return", "21", "\n", "}", "\n\n", "// Pay-to-script-hash script.", "if", "valid", ",", "_", ":=", "isScriptHash", "(", "pkScript", ")", ";", "valid", "{", "return", "21", "\n", "}", "\n\n", "// Pay-to-pubkey (compressed or uncompressed) script.", "if", "valid", ",", "_", ":=", "isPubKey", "(", "pkScript", ")", ";", "valid", "{", "return", "33", "\n", "}", "\n\n", "// When none of the above special cases apply, encode the script as is", "// preceded by the sum of its size and the number of special cases", "// encoded as a variable length quantity.", "return", "serializeSizeVLQ", "(", "uint64", "(", "len", "(", "pkScript", ")", "+", "numSpecialScripts", ")", ")", "+", "len", "(", "pkScript", ")", "\n", "}" ]

[ "compressedScriptSize", "returns", "the", "number", "of", "bytes", "the", "passed", "script", "would", "take", "when", "encoded", "with", "the", "domain", "specific", "compression", "algorithm", "described", "above", "." ]

[ "func", "decodeCompressedScriptSize", "(", "serialized", "[", "]", "byte", ")", "int", "{", "scriptSize", ",", "bytesRead", ":=", "deserializeVLQ", "(", "serialized", ")", "\n", "if", "bytesRead", "==", "0", "{", "return", "0", "\n", "}", "\n\n", "switch", "scriptSize", "{", "case", "cstPayToPubKeyHash", ":", "return", "21", "\n\n", "case", "cstPayToScriptHash", ":", "return", "21", "\n\n", "case", "cstPayToPubKeyComp2", ",", "cstPayToPubKeyComp3", ",", "cstPayToPubKeyUncomp4", ",", "cstPayToPubKeyUncomp5", ":", "return", "33", "\n", "}", "\n\n", "scriptSize", "-=", "numSpecialScripts", "\n", "scriptSize", "+=", "uint64", "(", "bytesRead", ")", "\n", "return", "int", "(", "scriptSize", ")", "\n", "}" ]

[ "decodeCompressedScriptSize", "treats", "the", "passed", "serialized", "bytes", "as", "a", "compressed", "script", "possibly", "followed", "by", "other", "data", "and", "returns", "the", "number", "of", "bytes", "it", "occupies", "taking", "into", "account", "the", "special", "encoding", "of", "the", "script", "size", "by", "the", "domain", "specific", "compression", "algorithm", "described", "above", "." ]

[ "func", "putCompressedScript", "(", "target", ",", "pkScript", "[", "]", "byte", ")", "int", "{", "// Pay-to-pubkey-hash script.", "if", "valid", ",", "hash", ":=", "isPubKeyHash", "(", "pkScript", ")", ";", "valid", "{", "target", "[", "0", "]", "=", "cstPayToPubKeyHash", "\n", "copy", "(", "target", "[", "1", ":", "21", "]", ",", "hash", ")", "\n", "return", "21", "\n", "}", "\n\n", "// Pay-to-script-hash script.", "if", "valid", ",", "hash", ":=", "isScriptHash", "(", "pkScript", ")", ";", "valid", "{", "target", "[", "0", "]", "=", "cstPayToScriptHash", "\n", "copy", "(", "target", "[", "1", ":", "21", "]", ",", "hash", ")", "\n", "return", "21", "\n", "}", "\n\n", "// Pay-to-pubkey (compressed or uncompressed) script.", "if", "valid", ",", "serializedPubKey", ":=", "isPubKey", "(", "pkScript", ")", ";", "valid", "{", "pubKeyFormat", ":=", "serializedPubKey", "[", "0", "]", "\n", "switch", "pubKeyFormat", "{", "case", "0x02", ",", "0x03", ":", "target", "[", "0", "]", "=", "pubKeyFormat", "\n", "copy", "(", "target", "[", "1", ":", "33", "]", ",", "serializedPubKey", "[", "1", ":", "33", "]", ")", "\n", "return", "33", "\n", "case", "0x04", ":", "// Encode the oddness of the serialized pubkey into the", "// compressed script type.", "target", "[", "0", "]", "=", "pubKeyFormat", "|", "(", "serializedPubKey", "[", "64", "]", "&", "0x01", ")", "\n", "copy", "(", "target", "[", "1", ":", "33", "]", ",", "serializedPubKey", "[", "1", ":", "33", "]", ")", "\n", "return", "33", "\n", "}", "\n", "}", "\n\n", "// When none of the above special cases apply, encode the unmodified", "// script preceded by the sum of its size and the number of special", "// cases encoded as a variable length quantity.", "encodedSize", ":=", "uint64", "(", "len", "(", "pkScript", ")", "+", "numSpecialScripts", ")", "\n", "vlqSizeLen", ":=", "putVLQ", "(", "target", ",", "encodedSize", ")", "\n", "copy", "(", "target", "[", "vlqSizeLen", ":", "]", ",", "pkScript", ")", "\n", "return", "vlqSizeLen", "+", "len", "(", "pkScript", ")", "\n", "}" ]

[ "putCompressedScript", "compresses", "the", "passed", "script", "according", "to", "the", "domain", "specific", "compression", "algorithm", "described", "above", "directly", "into", "the", "passed", "target", "byte", "slice", ".", "The", "target", "byte", "slice", "must", "be", "at", "least", "large", "enough", "to", "handle", "the", "number", "of", "bytes", "returned", "by", "the", "compressedScriptSize", "function", "or", "it", "will", "panic", "." ]

[ "func", "decompressTxOutAmount", "(", "amount", "uint64", ")", "uint64", "{", "// No need to do any work if it's zero.", "if", "amount", "==", "0", "{", "return", "0", "\n", "}", "\n\n", "// The decompressed amount is either of the following two equations:", "// x = 1 + 10*(9*n + d - 1) + e", "// x = 1 + 10*(n - 1) + 9", "amount", "--", "\n\n", "// The decompressed amount is now one of the following two equations:", "// x = 10*(9*n + d - 1) + e", "// x = 10*(n - 1) + 9", "exponent", ":=", "amount", "%", "10", "\n", "amount", "/=", "10", "\n\n", "// The decompressed amount is now one of the following two equations:", "// x = 9*n + d - 1 | where e < 9", "// x = n - 1 | where e = 9", "n", ":=", "uint64", "(", "0", ")", "\n", "if", "exponent", "<", "9", "{", "lastDigit", ":=", "amount", "%", "9", "+", "1", "\n", "amount", "/=", "9", "\n", "n", "=", "amount", "*", "10", "+", "lastDigit", "\n", "}", "else", "{", "n", "=", "amount", "+", "1", "\n", "}", "\n\n", "// Apply the exponent.", "for", ";", "exponent", ">", "0", ";", "exponent", "--", "{", "n", "*=", "10", "\n", "}", "\n\n", "return", "n", "\n", "}" ]

[ "decompressTxOutAmount", "returns", "the", "original", "amount", "the", "passed", "compressed", "amount", "represents", "according", "to", "the", "domain", "specific", "compression", "algorithm", "described", "above", "." ]

[ "func", "putCompressedTxOut", "(", "target", "[", "]", "byte", ",", "amount", "uint64", ",", "pkScript", "[", "]", "byte", ")", "int", "{", "offset", ":=", "putVLQ", "(", "target", ",", "compressTxOutAmount", "(", "amount", ")", ")", "\n", "offset", "+=", "putCompressedScript", "(", "target", "[", "offset", ":", "]", ",", "pkScript", ")", "\n", "return", "offset", "\n", "}" ]

[ "putCompressedTxOut", "compresses", "the", "passed", "amount", "and", "script", "according", "to", "their", "domain", "specific", "compression", "algorithms", "and", "encodes", "them", "directly", "into", "the", "passed", "target", "byte", "slice", "with", "the", "format", "described", "above", ".", "The", "target", "byte", "slice", "must", "be", "at", "least", "large", "enough", "to", "handle", "the", "number", "of", "bytes", "returned", "by", "the", "compressedTxOutSize", "function", "or", "it", "will", "panic", "." ]

[ "func", "decodeCompressedTxOut", "(", "serialized", "[", "]", "byte", ")", "(", "uint64", ",", "[", "]", "byte", ",", "int", ",", "error", ")", "{", "// Deserialize the compressed amount and ensure there are bytes", "// remaining for the compressed script.", "compressedAmount", ",", "bytesRead", ":=", "deserializeVLQ", "(", "serialized", ")", "\n", "if", "bytesRead", ">=", "len", "(", "serialized", ")", "{", "return", "0", ",", "nil", ",", "bytesRead", ",", "errDeserialize", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n\n", "// Decode the compressed script size and ensure there are enough bytes", "// left in the slice for it.", "scriptSize", ":=", "decodeCompressedScriptSize", "(", "serialized", "[", "bytesRead", ":", "]", ")", "\n", "if", "len", "(", "serialized", "[", "bytesRead", ":", "]", ")", "<", "scriptSize", "{", "return", "0", ",", "nil", ",", "bytesRead", ",", "errDeserialize", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n\n", "// Decompress and return the amount and script.", "amount", ":=", "decompressTxOutAmount", "(", "compressedAmount", ")", "\n", "script", ":=", "decompressScript", "(", "serialized", "[", "bytesRead", ":", "bytesRead", "+", "scriptSize", "]", ")", "\n", "return", "amount", ",", "script", ",", "bytesRead", "+", "scriptSize", ",", "nil", "\n", "}" ]

[ "decodeCompressedTxOut", "decodes", "the", "passed", "compressed", "txout", "possibly", "followed", "by", "other", "data", "into", "its", "uncompressed", "amount", "and", "script", "and", "returns", "them", "along", "with", "the", "number", "of", "bytes", "they", "occupied", "prior", "to", "decompression", "." ]

[ "func", "(", "msg", "*", "MsgAddr", ")", "AddAddress", "(", "na", "*", "NetAddress", ")", "error", "{", "if", "len", "(", "msg", ".", "AddrList", ")", "+", "1", ">", "MaxAddrPerMsg", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "MaxAddrPerMsg", ")", "\n", "return", "messageError", "(", "\"", "\"", ",", "str", ")", "\n", "}", "\n\n", "msg", ".", "AddrList", "=", "append", "(", "msg", ".", "AddrList", ",", "na", ")", "\n", "return", "nil", "\n", "}" ]

[ "AddAddress", "adds", "a", "known", "active", "peer", "to", "the", "message", "." ]

[ "func", "(", "msg", "*", "MsgAddr", ")", "AddAddresses", "(", "netAddrs", "...", "*", "NetAddress", ")", "error", "{", "for", "_", ",", "na", ":=", "range", "netAddrs", "{", "err", ":=", "msg", ".", "AddAddress", "(", "na", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AddAddresses", "adds", "multiple", "known", "active", "peers", "to", "the", "message", "." ]

[ "func", "(", "pop", "*", "parsedOpcode", ")", "isConditional", "(", ")", "bool", "{", "switch", "pop", ".", "opcode", ".", "value", "{", "case", "OP_IF", ":", "return", "true", "\n", "case", "OP_NOTIF", ":", "return", "true", "\n", "case", "OP_ELSE", ":", "return", "true", "\n", "case", "OP_ENDIF", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "isConditional", "returns", "whether", "or", "not", "the", "opcode", "is", "a", "conditional", "opcode", "which", "changes", "the", "conditional", "execution", "stack", "when", "executed", "." ]

[ "func", "(", "pop", "*", "parsedOpcode", ")", "print", "(", "oneline", "bool", ")", "string", "{", "// The reference implementation one-line disassembly replaces opcodes", "// which represent values (e.g. OP_0 through OP_16 and OP_1NEGATE)", "// with the raw value. However, when not doing a one-line dissassembly,", "// we prefer to show the actual opcode names. Thus, only replace the", "// opcodes in question when the oneline flag is set.", "opcodeName", ":=", "pop", ".", "opcode", ".", "name", "\n", "if", "oneline", "{", "if", "replName", ",", "ok", ":=", "opcodeOnelineRepls", "[", "opcodeName", "]", ";", "ok", "{", "opcodeName", "=", "replName", "\n", "}", "\n\n", "// Nothing more to do for non-data push opcodes.", "if", "pop", ".", "opcode", ".", "length", "==", "1", "{", "return", "opcodeName", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pop", ".", "data", ")", "\n", "}", "\n\n", "// Nothing more to do for non-data push opcodes.", "if", "pop", ".", "opcode", ".", "length", "==", "1", "{", "return", "opcodeName", "\n", "}", "\n\n", "// Add length for the OP_PUSHDATA# opcodes.", "retString", ":=", "opcodeName", "\n", "switch", "pop", ".", "opcode", ".", "length", "{", "case", "-", "1", ":", "retString", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "pop", ".", "data", ")", ")", "\n", "case", "-", "2", ":", "retString", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "pop", ".", "data", ")", ")", "\n", "case", "-", "4", ":", "retString", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "pop", ".", "data", ")", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "retString", ",", "pop", ".", "data", ")", "\n", "}" ]

[ "print", "returns", "a", "human", "-", "readable", "string", "representation", "of", "the", "opcode", "for", "use", "in", "script", "disassembly", "." ]

[ "func", "(", "pop", "*", "parsedOpcode", ")", "bytes", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "retbytes", "[", "]", "byte", "\n", "if", "pop", ".", "opcode", ".", "length", ">", "0", "{", "retbytes", "=", "make", "(", "[", "]", "byte", ",", "1", ",", "pop", ".", "opcode", ".", "length", ")", "\n", "}", "else", "{", "retbytes", "=", "make", "(", "[", "]", "byte", ",", "1", ",", "1", "+", "len", "(", "pop", ".", "data", ")", "-", "pop", ".", "opcode", ".", "length", ")", "\n", "}", "\n\n", "retbytes", "[", "0", "]", "=", "pop", ".", "opcode", ".", "value", "\n", "if", "pop", ".", "opcode", ".", "length", "==", "1", "{", "if", "len", "(", "pop", ".", "data", ")", "!=", "0", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "pop", ".", "opcode", ".", "name", ",", "len", "(", "pop", ".", "data", ")", ",", "0", ")", "\n", "return", "nil", ",", "scriptError", "(", "ErrInternal", ",", "str", ")", "\n", "}", "\n", "return", "retbytes", ",", "nil", "\n", "}", "\n", "nbytes", ":=", "pop", ".", "opcode", ".", "length", "\n", "if", "pop", ".", "opcode", ".", "length", "<", "0", "{", "l", ":=", "len", "(", "pop", ".", "data", ")", "\n", "// tempting just to hardcode to avoid the complexity here.", "switch", "pop", ".", "opcode", ".", "length", "{", "case", "-", "1", ":", "retbytes", "=", "append", "(", "retbytes", ",", "byte", "(", "l", ")", ")", "\n", "nbytes", "=", "int", "(", "retbytes", "[", "1", "]", ")", "+", "len", "(", "retbytes", ")", "\n", "case", "-", "2", ":", "retbytes", "=", "append", "(", "retbytes", ",", "byte", "(", "l", "&", "0xff", ")", ",", "byte", "(", "l", ">>", "8", "&", "0xff", ")", ")", "\n", "nbytes", "=", "int", "(", "binary", ".", "LittleEndian", ".", "Uint16", "(", "retbytes", "[", "1", ":", "]", ")", ")", "+", "len", "(", "retbytes", ")", "\n", "case", "-", "4", ":", "retbytes", "=", "append", "(", "retbytes", ",", "byte", "(", "l", "&", "0xff", ")", ",", "byte", "(", "(", "l", ">>", "8", ")", "&", "0xff", ")", ",", "byte", "(", "(", "l", ">>", "16", ")", "&", "0xff", ")", ",", "byte", "(", "(", "l", ">>", "24", ")", "&", "0xff", ")", ")", "\n", "nbytes", "=", "int", "(", "binary", ".", "LittleEndian", ".", "Uint32", "(", "retbytes", "[", "1", ":", "]", ")", ")", "+", "len", "(", "retbytes", ")", "\n", "}", "\n", "}", "\n\n", "retbytes", "=", "append", "(", "retbytes", ",", "pop", ".", "data", "...", ")", "\n\n", "if", "len", "(", "retbytes", ")", "!=", "nbytes", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "pop", ".", "opcode", ".", "name", ",", "len", "(", "retbytes", ")", ",", "nbytes", ")", "\n", "return", "nil", ",", "scriptError", "(", "ErrInternal", ",", "str", ")", "\n", "}", "\n\n", "return", "retbytes", ",", "nil", "\n", "}" ]

[ "bytes", "returns", "any", "data", "associated", "with", "the", "opcode", "encoded", "as", "it", "would", "be", "in", "a", "script", ".", "This", "is", "used", "for", "unparsing", "scripts", "from", "parsed", "opcodes", "." ]

[ "func", "opcodeReserved", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "op", ".", "opcode", ".", "name", ")", "\n", "return", "scriptError", "(", "ErrReservedOpcode", ",", "str", ")", "\n", "}" ]

[ "opcodeReserved", "is", "a", "common", "handler", "for", "all", "reserved", "opcodes", ".", "It", "returns", "an", "appropriate", "error", "indicating", "the", "opcode", "is", "reserved", "." ]

[ "func", "opcodeFalse", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "vm", ".", "dstack", ".", "PushByteArray", "(", "nil", ")", "\n", "return", "nil", "\n", "}" ]

[ "opcodeFalse", "pushes", "an", "empty", "array", "to", "the", "data", "stack", "to", "represent", "false", ".", "Note", "that", "0", "when", "encoded", "as", "a", "number", "according", "to", "the", "numeric", "encoding", "consensus", "rules", "is", "an", "empty", "array", "." ]

[ "func", "opcode1Negate", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "vm", ".", "dstack", ".", "PushInt", "(", "scriptNum", "(", "-", "1", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "opcode1Negate", "pushes", "-", "1", "encoded", "as", "a", "number", "to", "the", "data", "stack", "." ]

[ "func", "opcodeNop", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "switch", "op", ".", "opcode", ".", "value", "{", "case", "OP_NOP1", ",", "OP_NOP4", ",", "OP_NOP5", ",", "OP_NOP6", ",", "OP_NOP7", ",", "OP_NOP8", ",", "OP_NOP9", ",", "OP_NOP10", ":", "if", "vm", ".", "hasFlag", "(", "ScriptDiscourageUpgradableNops", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "op", ".", "opcode", ".", "value", "-", "(", "OP_NOP1", "-", "1", ")", ")", "\n", "return", "scriptError", "(", "ErrDiscourageUpgradableNOPs", ",", "str", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "opcodeNop", "is", "a", "common", "handler", "for", "the", "NOP", "family", "of", "opcodes", ".", "As", "the", "name", "implies", "it", "generally", "does", "nothing", "however", "it", "will", "return", "an", "error", "when", "the", "flag", "to", "discourage", "use", "of", "NOPs", "is", "set", "for", "select", "opcodes", "." ]

[ "func", "abstractVerify", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ",", "c", "ErrorCode", ")", "error", "{", "verified", ",", "err", ":=", "vm", ".", "dstack", ".", "PopBool", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "!", "verified", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "op", ".", "opcode", ".", "name", ")", "\n", "return", "scriptError", "(", "c", ",", "str", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "abstractVerify", "examines", "the", "top", "item", "on", "the", "data", "stack", "as", "a", "boolean", "value", "and", "verifies", "it", "evaluates", "to", "true", ".", "An", "error", "is", "returned", "either", "when", "there", "is", "no", "item", "on", "the", "stack", "or", "when", "that", "item", "evaluates", "to", "false", ".", "In", "the", "latter", "case", "where", "the", "verification", "fails", "specifically", "due", "to", "the", "top", "item", "evaluating", "to", "false", "the", "returned", "error", "will", "use", "the", "passed", "error", "code", "." ]

[ "func", "opcodeVerify", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "return", "abstractVerify", "(", "op", ",", "vm", ",", "ErrVerify", ")", "\n", "}" ]

[ "opcodeVerify", "examines", "the", "top", "item", "on", "the", "data", "stack", "as", "a", "boolean", "value", "and", "verifies", "it", "evaluates", "to", "true", ".", "An", "error", "is", "returned", "if", "it", "does", "not", "." ]

[ "func", "verifyLockTime", "(", "txLockTime", ",", "threshold", ",", "lockTime", "int64", ")", "error", "{", "// The lockTimes in both the script and transaction must be of the same", "// type.", "if", "!", "(", "(", "txLockTime", "<", "threshold", "&&", "lockTime", "<", "threshold", ")", "||", "(", "txLockTime", ">=", "threshold", "&&", "lockTime", ">=", "threshold", ")", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "txLockTime", ",", "lockTime", ")", "\n", "return", "scriptError", "(", "ErrUnsatisfiedLockTime", ",", "str", ")", "\n", "}", "\n\n", "if", "lockTime", ">", "txLockTime", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "lockTime", ",", "txLockTime", ")", "\n", "return", "scriptError", "(", "ErrUnsatisfiedLockTime", ",", "str", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "verifyLockTime", "is", "a", "helper", "function", "used", "to", "validate", "locktimes", "." ]

[ "func", "opcodeCheckLockTimeVerify", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "// If the ScriptVerifyCheckLockTimeVerify script flag is not set, treat", "// opcode as OP_NOP2 instead.", "if", "!", "vm", ".", "hasFlag", "(", "ScriptVerifyCheckLockTimeVerify", ")", "{", "if", "vm", ".", "hasFlag", "(", "ScriptDiscourageUpgradableNops", ")", "{", "return", "scriptError", "(", "ErrDiscourageUpgradableNOPs", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// The current transaction locktime is a uint32 resulting in a maximum", "// locktime of 2^32-1 (the year 2106). However, scriptNums are signed", "// and therefore a standard 4-byte scriptNum would only support up to a", "// maximum of 2^31-1 (the year 2038). Thus, a 5-byte scriptNum is used", "// here since it will support up to 2^39-1 which allows dates beyond the", "// current locktime limit.", "//", "// PeekByteArray is used here instead of PeekInt because we do not want", "// to be limited to a 4-byte integer for reasons specified above.", "so", ",", "err", ":=", "vm", ".", "dstack", ".", "PeekByteArray", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "lockTime", ",", "err", ":=", "makeScriptNum", "(", "so", ",", "vm", ".", "dstack", ".", "verifyMinimalData", ",", "5", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// In the rare event that the argument needs to be < 0 due to some", "// arithmetic being done first, you can always use", "// 0 OP_MAX OP_CHECKLOCKTIMEVERIFY.", "if", "lockTime", "<", "0", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "lockTime", ")", "\n", "return", "scriptError", "(", "ErrNegativeLockTime", ",", "str", ")", "\n", "}", "\n\n", "// The lock time field of a transaction is either a block height at", "// which the transaction is finalized or a timestamp depending on if the", "// value is before the txscript.LockTimeThreshold. When it is under the", "// threshold it is a block height.", "err", "=", "verifyLockTime", "(", "int64", "(", "vm", ".", "tx", ".", "LockTime", ")", ",", "LockTimeThreshold", ",", "int64", "(", "lockTime", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// The lock time feature can also be disabled, thereby bypassing", "// OP_CHECKLOCKTIMEVERIFY, if every transaction input has been finalized by", "// setting its sequence to the maximum value (wire.MaxTxInSequenceNum). This", "// condition would result in the transaction being allowed into the blockchain", "// making the opcode ineffective.", "//", "// This condition is prevented by enforcing that the input being used by", "// the opcode is unlocked (its sequence number is less than the max", "// value). This is sufficient to prove correctness without having to", "// check every input.", "//", "// NOTE: This implies that even if the transaction is not finalized due to", "// another input being unlocked, the opcode execution will still fail when the", "// input being used by the opcode is locked.", "if", "vm", ".", "tx", ".", "TxIn", "[", "vm", ".", "txIdx", "]", ".", "Sequence", "==", "wire", ".", "MaxTxInSequenceNum", "{", "return", "scriptError", "(", "ErrUnsatisfiedLockTime", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "opcodeCheckLockTimeVerify", "compares", "the", "top", "item", "on", "the", "data", "stack", "to", "the", "LockTime", "field", "of", "the", "transaction", "containing", "the", "script", "signature", "validating", "if", "the", "transaction", "outputs", "are", "spendable", "yet", ".", "If", "flag", "ScriptVerifyCheckLockTimeVerify", "is", "not", "set", "the", "code", "continues", "as", "if", "OP_NOP2", "were", "executed", "." ]

[ "func", "opcodeCheckSequenceVerify", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "// If the ScriptVerifyCheckSequenceVerify script flag is not set, treat", "// opcode as OP_NOP3 instead.", "if", "!", "vm", ".", "hasFlag", "(", "ScriptVerifyCheckSequenceVerify", ")", "{", "if", "vm", ".", "hasFlag", "(", "ScriptDiscourageUpgradableNops", ")", "{", "return", "scriptError", "(", "ErrDiscourageUpgradableNOPs", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// The current transaction sequence is a uint32 resulting in a maximum", "// sequence of 2^32-1. However, scriptNums are signed and therefore a", "// standard 4-byte scriptNum would only support up to a maximum of", "// 2^31-1. Thus, a 5-byte scriptNum is used here since it will support", "// up to 2^39-1 which allows sequences beyond the current sequence", "// limit.", "//", "// PeekByteArray is used here instead of PeekInt because we do not want", "// to be limited to a 4-byte integer for reasons specified above.", "so", ",", "err", ":=", "vm", ".", "dstack", ".", "PeekByteArray", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "stackSequence", ",", "err", ":=", "makeScriptNum", "(", "so", ",", "vm", ".", "dstack", ".", "verifyMinimalData", ",", "5", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// In the rare event that the argument needs to be < 0 due to some", "// arithmetic being done first, you can always use", "// 0 OP_MAX OP_CHECKSEQUENCEVERIFY.", "if", "stackSequence", "<", "0", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "stackSequence", ")", "\n", "return", "scriptError", "(", "ErrNegativeLockTime", ",", "str", ")", "\n", "}", "\n\n", "sequence", ":=", "int64", "(", "stackSequence", ")", "\n\n", "// To provide for future soft-fork extensibility, if the", "// operand has the disabled lock-time flag set,", "// CHECKSEQUENCEVERIFY behaves as a NOP.", "if", "sequence", "&", "int64", "(", "wire", ".", "SequenceLockTimeDisabled", ")", "!=", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Transaction version numbers not high enough to trigger CSV rules must", "// fail.", "if", "vm", ".", "tx", ".", "Version", "<", "2", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "vm", ".", "tx", ".", "Version", ")", "\n", "return", "scriptError", "(", "ErrUnsatisfiedLockTime", ",", "str", ")", "\n", "}", "\n\n", "// Sequence numbers with their most significant bit set are not", "// consensus constrained. Testing that the transaction's sequence", "// number does not have this bit set prevents using this property", "// to get around a CHECKSEQUENCEVERIFY check.", "txSequence", ":=", "int64", "(", "vm", ".", "tx", ".", "TxIn", "[", "vm", ".", "txIdx", "]", ".", "Sequence", ")", "\n", "if", "txSequence", "&", "int64", "(", "wire", ".", "SequenceLockTimeDisabled", ")", "!=", "0", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "txSequence", ")", "\n", "return", "scriptError", "(", "ErrUnsatisfiedLockTime", ",", "str", ")", "\n", "}", "\n\n", "// Mask off non-consensus bits before doing comparisons.", "lockTimeMask", ":=", "int64", "(", "wire", ".", "SequenceLockTimeIsSeconds", "|", "wire", ".", "SequenceLockTimeMask", ")", "\n", "return", "verifyLockTime", "(", "txSequence", "&", "lockTimeMask", ",", "wire", ".", "SequenceLockTimeIsSeconds", ",", "sequence", "&", "lockTimeMask", ")", "\n", "}" ]

[ "opcodeCheckSequenceVerify", "compares", "the", "top", "item", "on", "the", "data", "stack", "to", "the", "LockTime", "field", "of", "the", "transaction", "containing", "the", "script", "signature", "validating", "if", "the", "transaction", "outputs", "are", "spendable", "yet", ".", "If", "flag", "ScriptVerifyCheckSequenceVerify", "is", "not", "set", "the", "code", "continues", "as", "if", "OP_NOP3", "were", "executed", "." ]

[ "func", "calcHash", "(", "buf", "[", "]", "byte", ",", "hasher", "hash", ".", "Hash", ")", "[", "]", "byte", "{", "hasher", ".", "Write", "(", "buf", ")", "\n", "return", "hasher", ".", "Sum", "(", "nil", ")", "\n", "}" ]

[ "calcHash", "calculates", "the", "hash", "of", "hasher", "over", "buf", "." ]

[ "func", "opcodeCodeSeparator", "(", "op", "*", "parsedOpcode", ",", "vm", "*", "Engine", ")", "error", "{", "vm", ".", "lastCodeSep", "=", "vm", ".", "scriptOff", "\n", "return", "nil", "\n", "}" ]

[ "opcodeCodeSeparator", "stores", "the", "current", "script", "offset", "as", "the", "most", "recently", "seen", "OP_CODESEPARATOR", "which", "is", "used", "during", "signature", "checking", ".", "This", "opcode", "does", "not", "change", "the", "contents", "of", "the", "data", "stack", "." ]

[ "func", "HashToBig", "(", "hash", "*", "chainhash", ".", "Hash", ")", "*", "big", ".", "Int", "{", "// A Hash is in little-endian, but the big package wants the bytes in", "// big-endian, so reverse them.", "buf", ":=", "*", "hash", "\n", "blen", ":=", "len", "(", "buf", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "blen", "/", "2", ";", "i", "++", "{", "buf", "[", "i", "]", ",", "buf", "[", "blen", "-", "1", "-", "i", "]", "=", "buf", "[", "blen", "-", "1", "-", "i", "]", ",", "buf", "[", "i", "]", "\n", "}", "\n\n", "return", "new", "(", "big", ".", "Int", ")", ".", "SetBytes", "(", "buf", "[", ":", "]", ")", "\n", "}" ]

[ "HashToBig", "converts", "a", "chainhash", ".", "Hash", "into", "a", "big", ".", "Int", "that", "can", "be", "used", "to", "perform", "math", "comparisons", "." ]

[ "func", "(", "b", "*", "BlockChain", ")", "calcEasiestDifficulty", "(", "bits", "uint32", ",", "duration", "time", ".", "Duration", ")", "uint32", "{", "// Convert types used in the calculations below.", "durationVal", ":=", "int64", "(", "duration", "/", "time", ".", "Second", ")", "\n", "adjustmentFactor", ":=", "big", ".", "NewInt", "(", "b", ".", "chainParams", ".", "RetargetAdjustmentFactor", ")", "\n\n", "// The test network rules allow minimum difficulty blocks after more", "// than twice the desired amount of time needed to generate a block has", "// elapsed.", "if", "b", ".", "chainParams", ".", "ReduceMinDifficulty", "{", "reductionTime", ":=", "int64", "(", "b", ".", "chainParams", ".", "MinDiffReductionTime", "/", "time", ".", "Second", ")", "\n", "if", "durationVal", ">", "reductionTime", "{", "return", "b", ".", "chainParams", ".", "PowLimitBits", "\n", "}", "\n", "}", "\n\n", "// Since easier difficulty equates to higher numbers, the easiest", "// difficulty for a given duration is the largest value possible given", "// the number of retargets for the duration and starting difficulty", "// multiplied by the max adjustment factor.", "newTarget", ":=", "CompactToBig", "(", "bits", ")", "\n", "for", "durationVal", ">", "0", "&&", "newTarget", ".", "Cmp", "(", "b", ".", "chainParams", ".", "PowLimit", ")", "<", "0", "{", "newTarget", ".", "Mul", "(", "newTarget", ",", "adjustmentFactor", ")", "\n", "durationVal", "-=", "b", ".", "maxRetargetTimespan", "\n", "}", "\n\n", "// Limit new value to the proof of work limit.", "if", "newTarget", ".", "Cmp", "(", "b", ".", "chainParams", ".", "PowLimit", ")", ">", "0", "{", "newTarget", ".", "Set", "(", "b", ".", "chainParams", ".", "PowLimit", ")", "\n", "}", "\n\n", "return", "BigToCompact", "(", "newTarget", ")", "\n", "}" ]

[ "calcEasiestDifficulty", "calculates", "the", "easiest", "possible", "difficulty", "that", "a", "block", "can", "have", "given", "starting", "difficulty", "bits", "and", "a", "duration", ".", "It", "is", "mainly", "used", "to", "verify", "that", "claimed", "proof", "of", "work", "by", "a", "block", "is", "sane", "as", "compared", "to", "a", "known", "good", "checkpoint", "." ]

[ "func", "(", "b", "*", "BlockChain", ")", "calcNextRequiredDifficulty", "(", "lastNode", "*", "blockNode", ",", "newBlockTime", "time", ".", "Time", ")", "(", "uint32", ",", "error", ")", "{", "// Genesis block.", "if", "lastNode", "==", "nil", "{", "return", "b", ".", "chainParams", ".", "PowLimitBits", ",", "nil", "\n", "}", "\n\n", "// Return the previous block's difficulty requirements if this block", "// is not at a difficulty retarget interval.", "if", "(", "lastNode", ".", "height", "+", "1", ")", "%", "b", ".", "blocksPerRetarget", "!=", "0", "{", "// For networks that support it, allow special reduction of the", "// required difficulty once too much time has elapsed without", "// mining a block.", "if", "b", ".", "chainParams", ".", "ReduceMinDifficulty", "{", "// Return minimum difficulty when more than the desired", "// amount of time has elapsed without mining a block.", "reductionTime", ":=", "int64", "(", "b", ".", "chainParams", ".", "MinDiffReductionTime", "/", "time", ".", "Second", ")", "\n", "allowMinTime", ":=", "lastNode", ".", "timestamp", "+", "reductionTime", "\n", "if", "newBlockTime", ".", "Unix", "(", ")", ">", "allowMinTime", "{", "return", "b", ".", "chainParams", ".", "PowLimitBits", ",", "nil", "\n", "}", "\n\n", "// The block was mined within the desired timeframe, so", "// return the difficulty for the last block which did", "// not have the special minimum difficulty rule applied.", "return", "b", ".", "findPrevTestNetDifficulty", "(", "lastNode", ")", ",", "nil", "\n", "}", "\n\n", "// For the main network (or any unrecognized networks), simply", "// return the previous block's difficulty requirements.", "return", "lastNode", ".", "bits", ",", "nil", "\n", "}", "\n\n", "// Get the block node at the previous retarget (targetTimespan days", "// worth of blocks).", "firstNode", ":=", "lastNode", ".", "RelativeAncestor", "(", "b", ".", "blocksPerRetarget", "-", "1", ")", "\n", "if", "firstNode", "==", "nil", "{", "return", "0", ",", "AssertError", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Limit the amount of adjustment that can occur to the previous", "// difficulty.", "actualTimespan", ":=", "lastNode", ".", "timestamp", "-", "firstNode", ".", "timestamp", "\n", "adjustedTimespan", ":=", "actualTimespan", "\n", "if", "actualTimespan", "<", "b", ".", "minRetargetTimespan", "{", "adjustedTimespan", "=", "b", ".", "minRetargetTimespan", "\n", "}", "else", "if", "actualTimespan", ">", "b", ".", "maxRetargetTimespan", "{", "adjustedTimespan", "=", "b", ".", "maxRetargetTimespan", "\n", "}", "\n\n", "// Calculate new target difficulty as:", "// currentDifficulty * (adjustedTimespan / targetTimespan)", "// The result uses integer division which means it will be slightly", "// rounded down. Bitcoind also uses integer division to calculate this", "// result.", "oldTarget", ":=", "CompactToBig", "(", "lastNode", ".", "bits", ")", "\n", "newTarget", ":=", "new", "(", "big", ".", "Int", ")", ".", "Mul", "(", "oldTarget", ",", "big", ".", "NewInt", "(", "adjustedTimespan", ")", ")", "\n", "targetTimeSpan", ":=", "int64", "(", "b", ".", "chainParams", ".", "TargetTimespan", "/", "time", ".", "Second", ")", "\n", "newTarget", ".", "Div", "(", "newTarget", ",", "big", ".", "NewInt", "(", "targetTimeSpan", ")", ")", "\n\n", "// Limit new value to the proof of work limit.", "if", "newTarget", ".", "Cmp", "(", "b", ".", "chainParams", ".", "PowLimit", ")", ">", "0", "{", "newTarget", ".", "Set", "(", "b", ".", "chainParams", ".", "PowLimit", ")", "\n", "}", "\n\n", "// Log new target difficulty and return it. The new target logging is", "// intentionally converting the bits back to a number instead of using", "// newTarget since conversion to the compact representation loses", "// precision.", "newTargetBits", ":=", "BigToCompact", "(", "newTarget", ")", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "lastNode", ".", "height", "+", "1", ")", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "lastNode", ".", "bits", ",", "oldTarget", ")", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "newTargetBits", ",", "CompactToBig", "(", "newTargetBits", ")", ")", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "time", ".", "Duration", "(", "actualTimespan", ")", "*", "time", ".", "Second", ",", "time", ".", "Duration", "(", "adjustedTimespan", ")", "*", "time", ".", "Second", ",", "b", ".", "chainParams", ".", "TargetTimespan", ")", "\n\n", "return", "newTargetBits", ",", "nil", "\n", "}" ]

[ "calcNextRequiredDifficulty", "calculates", "the", "required", "difficulty", "for", "the", "block", "after", "the", "passed", "previous", "block", "node", "based", "on", "the", "difficulty", "retarget", "rules", ".", "This", "function", "differs", "from", "the", "exported", "CalcNextRequiredDifficulty", "in", "that", "the", "exported", "version", "uses", "the", "current", "best", "chain", "as", "the", "previous", "block", "node", "while", "this", "function", "accepts", "any", "block", "node", "." ]

[ "func", "(", "b", "*", "BlockChain", ")", "CalcNextRequiredDifficulty", "(", "timestamp", "time", ".", "Time", ")", "(", "uint32", ",", "error", ")", "{", "b", ".", "chainLock", ".", "Lock", "(", ")", "\n", "difficulty", ",", "err", ":=", "b", ".", "calcNextRequiredDifficulty", "(", "b", ".", "bestChain", ".", "Tip", "(", ")", ",", "timestamp", ")", "\n", "b", ".", "chainLock", ".", "Unlock", "(", ")", "\n", "return", "difficulty", ",", "err", "\n", "}" ]

[ "CalcNextRequiredDifficulty", "calculates", "the", "required", "difficulty", "for", "the", "block", "after", "the", "end", "of", "the", "current", "best", "chain", "based", "on", "the", "difficulty", "retarget", "rules", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "findCandidates", "(", "chain", "*", "blockchain", ".", "BlockChain", ",", "latestHash", "*", "chainhash", ".", "Hash", ")", "(", "[", "]", "*", "chaincfg", ".", "Checkpoint", ",", "error", ")", "{", "// Start with the latest block of the main chain.", "block", ",", "err", ":=", "chain", ".", "BlockByHash", "(", "latestHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Get the latest known checkpoint.", "latestCheckpoint", ":=", "chain", ".", "LatestCheckpoint", "(", ")", "\n", "if", "latestCheckpoint", "==", "nil", "{", "// Set the latest checkpoint to the genesis block if there isn't", "// already one.", "latestCheckpoint", "=", "&", "chaincfg", ".", "Checkpoint", "{", "Hash", ":", "activeNetParams", ".", "GenesisHash", ",", "Height", ":", "0", ",", "}", "\n", "}", "\n\n", "// The latest known block must be at least the last known checkpoint", "// plus required checkpoint confirmations.", "checkpointConfirmations", ":=", "int32", "(", "blockchain", ".", "CheckpointConfirmations", ")", "\n", "requiredHeight", ":=", "latestCheckpoint", ".", "Height", "+", "checkpointConfirmations", "\n", "if", "block", ".", "Height", "(", ")", "<", "requiredHeight", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "block", ".", "Height", "(", ")", ",", "latestCheckpoint", ".", "Height", ",", "checkpointConfirmations", ")", "\n", "}", "\n\n", "// For the first checkpoint, the required height is any block after the", "// genesis block, so long as the chain has at least the required number", "// of confirmations (which is enforced above).", "if", "len", "(", "activeNetParams", ".", "Checkpoints", ")", "==", "0", "{", "requiredHeight", "=", "1", "\n", "}", "\n\n", "// Indeterminate progress setup.", "numBlocksToTest", ":=", "block", ".", "Height", "(", ")", "-", "requiredHeight", "\n", "progressInterval", ":=", "(", "numBlocksToTest", "/", "100", ")", "+", "1", "// min 1", "\n", "fmt", ".", "Print", "(", "\"", "\"", ")", "\n", "defer", "fmt", ".", "Println", "(", ")", "\n\n", "// Loop backwards through the chain to find checkpoint candidates.", "candidates", ":=", "make", "(", "[", "]", "*", "chaincfg", ".", "Checkpoint", ",", "0", ",", "cfg", ".", "NumCandidates", ")", "\n", "numTested", ":=", "int32", "(", "0", ")", "\n", "for", "len", "(", "candidates", ")", "<", "cfg", ".", "NumCandidates", "&&", "block", ".", "Height", "(", ")", ">", "requiredHeight", "{", "// Display progress.", "if", "numTested", "%", "progressInterval", "==", "0", "{", "fmt", ".", "Print", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Determine if this block is a checkpoint candidate.", "isCandidate", ",", "err", ":=", "chain", ".", "IsCheckpointCandidate", "(", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// All checks passed, so this node seems like a reasonable", "// checkpoint candidate.", "if", "isCandidate", "{", "checkpoint", ":=", "chaincfg", ".", "Checkpoint", "{", "Height", ":", "block", ".", "Height", "(", ")", ",", "Hash", ":", "block", ".", "Hash", "(", ")", ",", "}", "\n", "candidates", "=", "append", "(", "candidates", ",", "&", "checkpoint", ")", "\n", "}", "\n\n", "prevHash", ":=", "&", "block", ".", "MsgBlock", "(", ")", ".", "Header", ".", "PrevBlock", "\n", "block", ",", "err", "=", "chain", ".", "BlockByHash", "(", "prevHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "numTested", "++", "\n", "}", "\n", "return", "candidates", ",", "nil", "\n", "}" ]

[ "findCandidates", "searches", "the", "chain", "backwards", "for", "checkpoint", "candidates", "and", "returns", "a", "slice", "of", "found", "candidates", "if", "any", ".", "It", "also", "stops", "searching", "for", "candidates", "at", "the", "last", "checkpoint", "that", "is", "already", "hard", "coded", "into", "btcchain", "since", "there", "is", "no", "point", "in", "finding", "candidates", "before", "already", "existing", "checkpoints", "." ]

[ "func", "showCandidate", "(", "candidateNum", "int", ",", "checkpoint", "*", "chaincfg", ".", "Checkpoint", ")", "{", "if", "cfg", ".", "UseGoOutput", "{", "fmt", ".", "Printf", "(", "\"", "\\\"", "\\\"", "\\n", "\"", ",", "candidateNum", ",", "checkpoint", ".", "Height", ",", "checkpoint", ".", "Hash", ")", "\n", "return", "\n", "}", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "candidateNum", ",", "checkpoint", ".", "Height", ",", "checkpoint", ".", "Hash", ")", "\n\n", "}" ]

[ "showCandidate", "display", "a", "checkpoint", "candidate", "using", "and", "output", "format", "determined", "by", "the", "configuration", "parameters", ".", "The", "Go", "syntax", "output", "uses", "the", "format", "the", "btcchain", "code", "expects", "for", "checkpoints", "added", "to", "the", "list", "." ]

[ "func", "(", "c", "deploymentChecker", ")", "Condition", "(", "node", "*", "blockNode", ")", "(", "bool", ",", "error", ")", "{", "conditionMask", ":=", "uint32", "(", "1", ")", "<<", "c", ".", "deployment", ".", "BitNumber", "\n", "version", ":=", "uint32", "(", "node", ".", "version", ")", "\n", "return", "(", "version", "&", "vbTopMask", "==", "vbTopBits", ")", "&&", "(", "version", "&", "conditionMask", "!=", "0", ")", ",", "nil", "\n", "}" ]

[ "Condition", "returns", "true", "when", "the", "specific", "bit", "defined", "by", "the", "deployment", "associated", "with", "the", "checker", "is", "set", ".", "This", "is", "part", "of", "the", "thresholdConditionChecker", "interface", "implementation", "." ]

[ "func", "(", "b", "*", "BlockChain", ")", "CalcNextBlockVersion", "(", ")", "(", "int32", ",", "error", ")", "{", "b", ".", "chainLock", ".", "Lock", "(", ")", "\n", "version", ",", "err", ":=", "b", ".", "calcNextBlockVersion", "(", "b", ".", "bestChain", ".", "Tip", "(", ")", ")", "\n", "b", ".", "chainLock", ".", "Unlock", "(", ")", "\n", "return", "version", ",", "err", "\n", "}" ]

[ "CalcNextBlockVersion", "calculates", "the", "expected", "version", "of", "the", "block", "after", "the", "end", "of", "the", "current", "best", "chain", "based", "on", "the", "state", "of", "started", "and", "locked", "in", "rule", "change", "deployments", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "NewMsgFilterLoad", "(", "filter", "[", "]", "byte", ",", "hashFuncs", "uint32", ",", "tweak", "uint32", ",", "flags", "BloomUpdateType", ")", "*", "MsgFilterLoad", "{", "return", "&", "MsgFilterLoad", "{", "Filter", ":", "filter", ",", "HashFuncs", ":", "hashFuncs", ",", "Tweak", ":", "tweak", ",", "Flags", ":", "flags", ",", "}", "\n", "}" ]

[ "NewMsgFilterLoad", "returns", "a", "new", "bitcoin", "filterload", "message", "that", "conforms", "to", "the", "Message", "interface", ".", "See", "MsgFilterLoad", "for", "details", "." ]

[ "func", "makeParams", "(", "rt", "reflect", ".", "Type", ",", "rv", "reflect", ".", "Value", ")", "[", "]", "interface", "{", "}", "{", "numFields", ":=", "rt", ".", "NumField", "(", ")", "\n", "params", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "numFields", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "numFields", ";", "i", "++", "{", "rtf", ":=", "rt", ".", "Field", "(", "i", ")", "\n", "rvf", ":=", "rv", ".", "Field", "(", "i", ")", "\n", "if", "rtf", ".", "Type", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "if", "rvf", ".", "IsNil", "(", ")", "{", "break", "\n", "}", "\n", "rvf", ".", "Elem", "(", ")", "\n", "}", "\n", "params", "=", "append", "(", "params", ",", "rvf", ".", "Interface", "(", ")", ")", "\n", "}", "\n\n", "return", "params", "\n", "}" ]

[ "makeParams", "creates", "a", "slice", "of", "interface", "values", "for", "the", "given", "struct", "." ]

[ "func", "MarshalCmd", "(", "id", "interface", "{", "}", ",", "cmd", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Look up the cmd type and error out if not registered.", "rt", ":=", "reflect", ".", "TypeOf", "(", "cmd", ")", "\n", "registerLock", ".", "RLock", "(", ")", "\n", "method", ",", "ok", ":=", "concreteTypeToMethod", "[", "rt", "]", "\n", "registerLock", ".", "RUnlock", "(", ")", "\n", "if", "!", "ok", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "method", ")", "\n", "return", "nil", ",", "makeError", "(", "ErrUnregisteredMethod", ",", "str", ")", "\n", "}", "\n\n", "// The provided command must not be nil.", "rv", ":=", "reflect", ".", "ValueOf", "(", "cmd", ")", "\n", "if", "rv", ".", "IsNil", "(", ")", "{", "str", ":=", "\"", "\"", "\n", "return", "nil", ",", "makeError", "(", "ErrInvalidType", ",", "str", ")", "\n", "}", "\n\n", "// Create a slice of interface values in the order of the struct fields", "// while respecting pointer fields as optional params and only adding", "// them if they are non-nil.", "params", ":=", "makeParams", "(", "rt", ".", "Elem", "(", ")", ",", "rv", ".", "Elem", "(", ")", ")", "\n\n", "// Generate and marshal the final JSON-RPC request.", "rawCmd", ",", "err", ":=", "NewRequest", "(", "id", ",", "method", ",", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "rawCmd", ")", "\n", "}" ]

[ "MarshalCmd", "marshals", "the", "passed", "command", "to", "a", "JSON", "-", "RPC", "request", "byte", "slice", "that", "is", "suitable", "for", "transmission", "to", "an", "RPC", "server", ".", "The", "provided", "command", "type", "must", "be", "a", "registered", "type", ".", "All", "commands", "provided", "by", "this", "package", "are", "registered", "by", "default", "." ]

[ "func", "checkNumParams", "(", "numParams", "int", ",", "info", "*", "methodInfo", ")", "error", "{", "if", "numParams", "<", "info", ".", "numReqParams", "||", "numParams", ">", "info", ".", "maxParams", "{", "if", "info", ".", "numReqParams", "==", "info", ".", "maxParams", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "info", ".", "numReqParams", ",", "numParams", ")", "\n", "return", "makeError", "(", "ErrNumParams", ",", "str", ")", "\n", "}", "\n\n", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "info", ".", "numReqParams", ",", "info", ".", "maxParams", ",", "numParams", ")", "\n", "return", "makeError", "(", "ErrNumParams", ",", "str", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkNumParams", "ensures", "the", "supplied", "number", "of", "params", "is", "at", "least", "the", "minimum", "required", "number", "for", "the", "command", "and", "less", "than", "the", "maximum", "allowed", "." ]

[ "func", "populateDefaults", "(", "numParams", "int", ",", "info", "*", "methodInfo", ",", "rv", "reflect", ".", "Value", ")", "{", "// When there are no more parameters left in the supplied parameters,", "// any remaining struct fields must be optional. Thus, populate them", "// with their associated default value as needed.", "for", "i", ":=", "numParams", ";", "i", "<", "info", ".", "maxParams", ";", "i", "++", "{", "rvf", ":=", "rv", ".", "Field", "(", "i", ")", "\n", "if", "defaultVal", ",", "ok", ":=", "info", ".", "defaults", "[", "i", "]", ";", "ok", "{", "rvf", ".", "Set", "(", "defaultVal", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "populateDefaults", "populates", "default", "values", "into", "any", "remaining", "optional", "struct", "fields", "that", "did", "not", "have", "parameters", "explicitly", "provided", ".", "The", "caller", "should", "have", "previously", "checked", "that", "the", "number", "of", "parameters", "being", "passed", "is", "at", "least", "the", "required", "number", "of", "parameters", "to", "avoid", "unnecessary", "work", "in", "this", "function", "but", "since", "required", "fields", "never", "have", "default", "values", "it", "will", "work", "properly", "even", "without", "the", "check", "." ]

[ "func", "UnmarshalCmd", "(", "r", "*", "Request", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "registerLock", ".", "RLock", "(", ")", "\n", "rtp", ",", "ok", ":=", "methodToConcreteType", "[", "r", ".", "Method", "]", "\n", "info", ":=", "methodToInfo", "[", "r", ".", "Method", "]", "\n", "registerLock", ".", "RUnlock", "(", ")", "\n", "if", "!", "ok", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "Method", ")", "\n", "return", "nil", ",", "makeError", "(", "ErrUnregisteredMethod", ",", "str", ")", "\n", "}", "\n", "rt", ":=", "rtp", ".", "Elem", "(", ")", "\n", "rvp", ":=", "reflect", ".", "New", "(", "rt", ")", "\n", "rv", ":=", "rvp", ".", "Elem", "(", ")", "\n\n", "// Ensure the number of parameters are correct.", "numParams", ":=", "len", "(", "r", ".", "Params", ")", "\n", "if", "err", ":=", "checkNumParams", "(", "numParams", ",", "&", "info", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Loop through each of the struct fields and unmarshal the associated", "// parameter into them.", "for", "i", ":=", "0", ";", "i", "<", "numParams", ";", "i", "++", "{", "rvf", ":=", "rv", ".", "Field", "(", "i", ")", "\n", "// Unmarshal the parameter into the struct field.", "concreteVal", ":=", "rvf", ".", "Addr", "(", ")", ".", "Interface", "(", ")", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "r", ".", "Params", "[", "i", "]", ",", "&", "concreteVal", ")", ";", "err", "!=", "nil", "{", "// The most common error is the wrong type, so", "// explicitly detect that error and make it nicer.", "fieldName", ":=", "strings", ".", "ToLower", "(", "rt", ".", "Field", "(", "i", ")", ".", "Name", ")", "\n", "if", "jerr", ",", "ok", ":=", "err", ".", "(", "*", "json", ".", "UnmarshalTypeError", ")", ";", "ok", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "i", "+", "1", ",", "fieldName", ",", "jerr", ".", "Type", ",", "jerr", ".", "Value", ")", "\n", "return", "nil", ",", "makeError", "(", "ErrInvalidType", ",", "str", ")", "\n", "}", "\n\n", "// Fallback to showing the underlying error.", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "i", "+", "1", ",", "fieldName", ",", "err", ")", "\n", "return", "nil", ",", "makeError", "(", "ErrInvalidType", ",", "str", ")", "\n", "}", "\n", "}", "\n\n", "// When there are less supplied parameters than the total number of", "// params, any remaining struct fields must be optional. Thus, populate", "// them with their associated default value as needed.", "if", "numParams", "<", "info", ".", "maxParams", "{", "populateDefaults", "(", "numParams", ",", "&", "info", ",", "rv", ")", "\n", "}", "\n\n", "return", "rvp", ".", "Interface", "(", ")", ",", "nil", "\n", "}" ]

[ "UnmarshalCmd", "unmarshals", "a", "JSON", "-", "RPC", "request", "into", "a", "suitable", "concrete", "command", "so", "long", "as", "the", "method", "type", "contained", "within", "the", "marshalled", "request", "is", "registered", "." ]

[ "func", "isNumeric", "(", "kind", "reflect", ".", "Kind", ")", "bool", "{", "switch", "kind", "{", "case", "reflect", ".", "Int", ",", "reflect", ".", "Int8", ",", "reflect", ".", "Int16", ",", "reflect", ".", "Int32", ",", "reflect", ".", "Int64", ",", "reflect", ".", "Uint", ",", "reflect", ".", "Uint8", ",", "reflect", ".", "Uint16", ",", "reflect", ".", "Uint32", ",", "reflect", ".", "Uint64", ",", "reflect", ".", "Float32", ",", "reflect", ".", "Float64", ":", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "isNumeric", "returns", "whether", "the", "passed", "reflect", "kind", "is", "a", "signed", "or", "unsigned", "integer", "of", "any", "magnitude", "or", "a", "float", "of", "any", "magnitude", "." ]

[ "func", "typesMaybeCompatible", "(", "dest", "reflect", ".", "Type", ",", "src", "reflect", ".", "Type", ")", "bool", "{", "// The same types are obviously compatible.", "if", "dest", "==", "src", "{", "return", "true", "\n", "}", "\n\n", "// When both types are numeric, they are potentially compatible.", "srcKind", ":=", "src", ".", "Kind", "(", ")", "\n", "destKind", ":=", "dest", ".", "Kind", "(", ")", "\n", "if", "isNumeric", "(", "destKind", ")", "&&", "isNumeric", "(", "srcKind", ")", "{", "return", "true", "\n", "}", "\n\n", "if", "srcKind", "==", "reflect", ".", "String", "{", "// Strings can potentially be converted to numeric types.", "if", "isNumeric", "(", "destKind", ")", "{", "return", "true", "\n", "}", "\n\n", "switch", "destKind", "{", "// Strings can potentially be converted to bools by", "// strconv.ParseBool.", "case", "reflect", ".", "Bool", ":", "return", "true", "\n\n", "// Strings can be converted to any other type which has as", "// underlying type of string.", "case", "reflect", ".", "String", ":", "return", "true", "\n\n", "// Strings can potentially be converted to arrays, slice,", "// structs, and maps via json.Unmarshal.", "case", "reflect", ".", "Array", ",", "reflect", ".", "Slice", ",", "reflect", ".", "Struct", ",", "reflect", ".", "Map", ":", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "typesMaybeCompatible", "returns", "whether", "the", "source", "type", "can", "possibly", "be", "assigned", "to", "the", "destination", "type", ".", "This", "is", "intended", "as", "a", "relatively", "quick", "check", "to", "weed", "out", "obviously", "invalid", "conversions", "." ]

[ "func", "baseType", "(", "arg", "reflect", ".", "Type", ")", "(", "reflect", ".", "Type", ",", "int", ")", "{", "var", "numIndirects", "int", "\n", "for", "arg", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "arg", "=", "arg", ".", "Elem", "(", ")", "\n", "numIndirects", "++", "\n", "}", "\n", "return", "arg", ",", "numIndirects", "\n", "}" ]

[ "baseType", "returns", "the", "type", "of", "the", "argument", "after", "indirecting", "through", "all", "pointers", "along", "with", "how", "many", "indirections", "were", "necessary", "." ]

[ "func", "NewAuthenticateCmd", "(", "username", ",", "passphrase", "string", ")", "*", "AuthenticateCmd", "{", "return", "&", "AuthenticateCmd", "{", "Username", ":", "username", ",", "Passphrase", ":", "passphrase", ",", "}", "\n", "}" ]

[ "NewAuthenticateCmd", "returns", "a", "new", "instance", "which", "can", "be", "used", "to", "issue", "an", "authenticate", "JSON", "-", "RPC", "command", "." ]

[ "func", "(", "f", "ServiceFlag", ")", "String", "(", ")", "string", "{", "// No flags are set.", "if", "f", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n\n", "// Add individual bit flags.", "s", ":=", "\"", "\"", "\n", "for", "_", ",", "flag", ":=", "range", "orderedSFStrings", "{", "if", "f", "&", "flag", "==", "flag", "{", "s", "+=", "sfStrings", "[", "flag", "]", "+", "\"", "\"", "\n", "f", "-=", "flag", "\n", "}", "\n", "}", "\n\n", "// Add any remaining flags which aren't accounted for as hex.", "s", "=", "strings", ".", "TrimRight", "(", "s", ",", "\"", "\"", ")", "\n", "if", "f", "!=", "0", "{", "s", "+=", "\"", "\"", "+", "strconv", ".", "FormatUint", "(", "uint64", "(", "f", ")", ",", "16", ")", "\n", "}", "\n", "s", "=", "strings", ".", "TrimLeft", "(", "s", ",", "\"", "\"", ")", "\n", "return", "s", "\n", "}" ]

[ "String", "returns", "the", "ServiceFlag", "in", "human", "-", "readable", "form", "." ]

[ "func", "(", "n", "BitcoinNet", ")", "String", "(", ")", "string", "{", "if", "s", ",", "ok", ":=", "bnStrings", "[", "n", "]", ";", "ok", "{", "return", "s", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "uint32", "(", "n", ")", ")", "\n", "}" ]

[ "String", "returns", "the", "BitcoinNet", "in", "human", "-", "readable", "form", "." ]

[ "func", "ipNet", "(", "ip", "string", ",", "ones", ",", "bits", "int", ")", "net", ".", "IPNet", "{", "return", "net", ".", "IPNet", "{", "IP", ":", "net", ".", "ParseIP", "(", "ip", ")", ",", "Mask", ":", "net", ".", "CIDRMask", "(", "ones", ",", "bits", ")", "}", "\n", "}" ]

[ "ipNet", "returns", "a", "net", ".", "IPNet", "struct", "given", "the", "passed", "IP", "address", "string", "number", "of", "one", "bits", "to", "include", "at", "the", "start", "of", "the", "mask", "and", "the", "total", "number", "of", "bits", "for", "the", "mask", "." ]

[ "func", "IsLocal", "(", "na", "*", "wire", ".", "NetAddress", ")", "bool", "{", "return", "na", ".", "IP", ".", "IsLoopback", "(", ")", "||", "zero4Net", ".", "Contains", "(", "na", ".", "IP", ")", "\n", "}" ]

[ "IsLocal", "returns", "whether", "or", "not", "the", "given", "address", "is", "a", "local", "address", "." ]

[ "func", "IsRoutable", "(", "na", "*", "wire", ".", "NetAddress", ")", "bool", "{", "return", "IsValid", "(", "na", ")", "&&", "!", "(", "IsRFC1918", "(", "na", ")", "||", "IsRFC2544", "(", "na", ")", "||", "IsRFC3927", "(", "na", ")", "||", "IsRFC4862", "(", "na", ")", "||", "IsRFC3849", "(", "na", ")", "||", "IsRFC4843", "(", "na", ")", "||", "IsRFC5737", "(", "na", ")", "||", "IsRFC6598", "(", "na", ")", "||", "IsLocal", "(", "na", ")", "||", "(", "IsRFC4193", "(", "na", ")", "&&", "!", "IsOnionCatTor", "(", "na", ")", ")", ")", "\n", "}" ]

[ "IsRoutable", "returns", "whether", "or", "not", "the", "passed", "address", "is", "routable", "over", "the", "public", "internet", ".", "This", "is", "true", "as", "long", "as", "the", "address", "is", "valid", "and", "is", "not", "in", "any", "reserved", "ranges", "." ]

[ "func", "(", "msg", "*", "MsgGetData", ")", "AddInvVect", "(", "iv", "*", "InvVect", ")", "error", "{", "if", "len", "(", "msg", ".", "InvList", ")", "+", "1", ">", "MaxInvPerMsg", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "MaxInvPerMsg", ")", "\n", "return", "messageError", "(", "\"", "\"", ",", "str", ")", "\n", "}", "\n\n", "msg", ".", "InvList", "=", "append", "(", "msg", ".", "InvList", ",", "iv", ")", "\n", "return", "nil", "\n", "}" ]

[ "AddInvVect", "adds", "an", "inventory", "vector", "to", "the", "message", "." ]

[ "func", "commandUsage", "(", "method", "string", ")", "{", "usage", ",", "err", ":=", "btcjson", ".", "MethodUsageText", "(", "method", ")", "\n", "if", "err", "!=", "nil", "{", "// This should never happen since the method was already checked", "// before calling this function, but be safe.", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "\"", "\"", ")", "\n", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "usage", ")", "\n", "}" ]

[ "commandUsage", "display", "the", "usage", "for", "a", "specific", "command", "." ]

[ "func", "usage", "(", "errorMessage", "string", ")", "{", "appName", ":=", "filepath", ".", "Base", "(", "os", ".", "Args", "[", "0", "]", ")", "\n", "appName", "=", "strings", ".", "TrimSuffix", "(", "appName", ",", "filepath", ".", "Ext", "(", "appName", ")", ")", "\n", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "errorMessage", ")", "\n", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "\"", "\"", ")", "\n", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\\n", "\"", ",", "appName", ")", "\n", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "showHelpMessage", ")", "\n", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "listCmdMessage", ")", "\n", "}" ]

[ "usage", "displays", "the", "general", "usage", "when", "the", "help", "flag", "is", "not", "displayed", "and", "and", "an", "invalid", "command", "was", "specified", ".", "The", "commandUsage", "function", "is", "used", "instead", "when", "a", "valid", "command", "was", "specified", "." ]

[ "func", "(", "bi", "*", "blockImporter", ")", "readBlock", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// The block file format is:", "// <network> <block length> <serialized block>", "var", "net", "uint32", "\n", "err", ":=", "binary", ".", "Read", "(", "bi", ".", "r", ",", "binary", ".", "LittleEndian", ",", "&", "net", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "!=", "io", ".", "EOF", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// No block and no error means there are no more blocks to read.", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "net", "!=", "uint32", "(", "activeNetParams", ".", "Net", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "net", ",", "uint32", "(", "activeNetParams", ".", "Net", ")", ")", "\n", "}", "\n\n", "// Read the block length and ensure it is sane.", "var", "blockLen", "uint32", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "bi", ".", "r", ",", "binary", ".", "LittleEndian", ",", "&", "blockLen", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "blockLen", ">", "wire", ".", "MaxBlockPayload", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "blockLen", ",", "wire", ".", "MaxBlockPayload", ")", "\n", "}", "\n\n", "serializedBlock", ":=", "make", "(", "[", "]", "byte", ",", "blockLen", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "bi", ".", "r", ",", "serializedBlock", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "serializedBlock", ",", "nil", "\n", "}" ]

[ "readBlock", "reads", "the", "next", "block", "from", "the", "input", "file", "." ]

[ "func", "(", "bi", "*", "blockImporter", ")", "processBlock", "(", "serializedBlock", "[", "]", "byte", ")", "(", "bool", ",", "error", ")", "{", "// Deserialize the block which includes checks for malformed blocks.", "block", ",", "err", ":=", "btcutil", ".", "NewBlockFromBytes", "(", "serializedBlock", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "// update progress statistics", "bi", ".", "lastBlockTime", "=", "block", ".", "MsgBlock", "(", ")", ".", "Header", ".", "Timestamp", "\n", "bi", ".", "receivedLogTx", "+=", "int64", "(", "len", "(", "block", ".", "MsgBlock", "(", ")", ".", "Transactions", ")", ")", "\n\n", "// Skip blocks that already exist.", "blockHash", ":=", "block", ".", "Hash", "(", ")", "\n", "exists", ",", "err", ":=", "bi", ".", "chain", ".", "HaveBlock", "(", "blockHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "exists", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "// Don't bother trying to process orphans.", "prevHash", ":=", "&", "block", ".", "MsgBlock", "(", ")", ".", "Header", ".", "PrevBlock", "\n", "if", "!", "prevHash", ".", "IsEqual", "(", "&", "zeroHash", ")", "{", "exists", ",", "err", ":=", "bi", ".", "chain", ".", "HaveBlock", "(", "prevHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "exists", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "prevHash", ")", "\n", "}", "\n", "}", "\n\n", "// Ensure the blocks follows all of the chain rules and match up to the", "// known checkpoints.", "isMainChain", ",", "isOrphan", ",", "err", ":=", "bi", ".", "chain", ".", "ProcessBlock", "(", "block", ",", "blockchain", ".", "BFFastAdd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "isMainChain", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "blockHash", ")", "\n", "}", "\n", "if", "isOrphan", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "blockHash", ")", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "processBlock", "potentially", "imports", "the", "block", "into", "the", "database", ".", "It", "first", "deserializes", "the", "raw", "block", "while", "checking", "for", "errors", ".", "Already", "known", "blocks", "are", "skipped", "and", "orphan", "blocks", "are", "considered", "errors", ".", "Finally", "it", "runs", "the", "block", "through", "the", "chain", "rules", "to", "ensure", "it", "follows", "all", "rules", "and", "matches", "up", "to", "the", "known", "checkpoint", ".", "Returns", "whether", "the", "block", "was", "imported", "along", "with", "any", "potential", "errors", "." ]

[ "func", "(", "bi", "*", "blockImporter", ")", "readHandler", "(", ")", "{", "out", ":", "for", "{", "// Read the next block from the file and if anything goes wrong", "// notify the status handler with the error and bail.", "serializedBlock", ",", "err", ":=", "bi", ".", "readBlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "bi", ".", "errChan", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "break", "out", "\n", "}", "\n\n", "// A nil block with no error means we're done.", "if", "serializedBlock", "==", "nil", "{", "break", "out", "\n", "}", "\n\n", "// Send the block or quit if we've been signalled to exit by", "// the status handler due to an error elsewhere.", "select", "{", "case", "bi", ".", "processQueue", "<-", "serializedBlock", ":", "case", "<-", "bi", ".", "quit", ":", "break", "out", "\n", "}", "\n", "}", "\n\n", "// Close the processing channel to signal no more blocks are coming.", "close", "(", "bi", ".", "processQueue", ")", "\n", "bi", ".", "wg", ".", "Done", "(", ")", "\n", "}" ]

[ "readHandler", "is", "the", "main", "handler", "for", "reading", "blocks", "from", "the", "import", "file", ".", "This", "allows", "block", "processing", "to", "take", "place", "in", "parallel", "with", "block", "reads", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "bi", "*", "blockImporter", ")", "logProgress", "(", ")", "{", "bi", ".", "receivedLogBlocks", "++", "\n\n", "now", ":=", "time", ".", "Now", "(", ")", "\n", "duration", ":=", "now", ".", "Sub", "(", "bi", ".", "lastLogTime", ")", "\n", "if", "duration", "<", "time", ".", "Second", "*", "time", ".", "Duration", "(", "cfg", ".", "Progress", ")", "{", "return", "\n", "}", "\n\n", "// Truncate the duration to 10s of milliseconds.", "durationMillis", ":=", "int64", "(", "duration", "/", "time", ".", "Millisecond", ")", "\n", "tDuration", ":=", "10", "*", "time", ".", "Millisecond", "*", "time", ".", "Duration", "(", "durationMillis", "/", "10", ")", "\n\n", "// Log information about new block height.", "blockStr", ":=", "\"", "\"", "\n", "if", "bi", ".", "receivedLogBlocks", "==", "1", "{", "blockStr", "=", "\"", "\"", "\n", "}", "\n", "txStr", ":=", "\"", "\"", "\n", "if", "bi", ".", "receivedLogTx", "==", "1", "{", "txStr", "=", "\"", "\"", "\n", "}", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "bi", ".", "receivedLogBlocks", ",", "blockStr", ",", "tDuration", ",", "bi", ".", "receivedLogTx", ",", "txStr", ",", "bi", ".", "lastHeight", ",", "bi", ".", "lastBlockTime", ")", "\n\n", "bi", ".", "receivedLogBlocks", "=", "0", "\n", "bi", ".", "receivedLogTx", "=", "0", "\n", "bi", ".", "lastLogTime", "=", "now", "\n", "}" ]

[ "logProgress", "logs", "block", "progress", "as", "an", "information", "message", ".", "In", "order", "to", "prevent", "spam", "it", "limits", "logging", "to", "one", "message", "every", "cfg", ".", "Progress", "seconds", "with", "duration", "and", "totals", "included", "." ]

[ "func", "(", "bi", "*", "blockImporter", ")", "processHandler", "(", ")", "{", "out", ":", "for", "{", "select", "{", "case", "serializedBlock", ",", "ok", ":=", "<-", "bi", ".", "processQueue", ":", "// We're done when the channel is closed.", "if", "!", "ok", "{", "break", "out", "\n", "}", "\n\n", "bi", ".", "blocksProcessed", "++", "\n", "bi", ".", "lastHeight", "++", "\n", "imported", ",", "err", ":=", "bi", ".", "processBlock", "(", "serializedBlock", ")", "\n", "if", "err", "!=", "nil", "{", "bi", ".", "errChan", "<-", "err", "\n", "break", "out", "\n", "}", "\n\n", "if", "imported", "{", "bi", ".", "blocksImported", "++", "\n", "}", "\n\n", "bi", ".", "logProgress", "(", ")", "\n\n", "case", "<-", "bi", ".", "quit", ":", "break", "out", "\n", "}", "\n", "}", "\n", "bi", ".", "wg", ".", "Done", "(", ")", "\n", "}" ]

[ "processHandler", "is", "the", "main", "handler", "for", "processing", "blocks", ".", "This", "allows", "block", "processing", "to", "take", "place", "in", "parallel", "with", "block", "reads", "from", "the", "import", "file", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "bi", "*", "blockImporter", ")", "statusHandler", "(", "resultsChan", "chan", "*", "importResults", ")", "{", "select", "{", "// An error from either of the goroutines means we're done so signal", "// caller with the error and signal all goroutines to quit.", "case", "err", ":=", "<-", "bi", ".", "errChan", ":", "resultsChan", "<-", "&", "importResults", "{", "blocksProcessed", ":", "bi", ".", "blocksProcessed", ",", "blocksImported", ":", "bi", ".", "blocksImported", ",", "err", ":", "err", ",", "}", "\n", "close", "(", "bi", ".", "quit", ")", "\n\n", "// The import finished normally.", "case", "<-", "bi", ".", "doneChan", ":", "resultsChan", "<-", "&", "importResults", "{", "blocksProcessed", ":", "bi", ".", "blocksProcessed", ",", "blocksImported", ":", "bi", ".", "blocksImported", ",", "err", ":", "nil", ",", "}", "\n", "}", "\n", "}" ]

[ "statusHandler", "waits", "for", "updates", "from", "the", "import", "operation", "and", "notifies", "the", "passed", "doneChan", "with", "the", "results", "of", "the", "import", ".", "It", "also", "causes", "all", "goroutines", "to", "exit", "if", "an", "error", "is", "reported", "from", "any", "of", "them", "." ]

[ "func", "(", "bi", "*", "blockImporter", ")", "Import", "(", ")", "chan", "*", "importResults", "{", "// Start up the read and process handling goroutines. This setup allows", "// blocks to be read from disk in parallel while being processed.", "bi", ".", "wg", ".", "Add", "(", "2", ")", "\n", "go", "bi", ".", "readHandler", "(", ")", "\n", "go", "bi", ".", "processHandler", "(", ")", "\n\n", "// Wait for the import to finish in a separate goroutine and signal", "// the status handler when done.", "go", "func", "(", ")", "{", "bi", ".", "wg", ".", "Wait", "(", ")", "\n", "bi", ".", "doneChan", "<-", "true", "\n", "}", "(", ")", "\n\n", "// Start the status handler and return the result channel that it will", "// send the results on when the import is done.", "resultChan", ":=", "make", "(", "chan", "*", "importResults", ")", "\n", "go", "bi", ".", "statusHandler", "(", "resultChan", ")", "\n", "return", "resultChan", "\n", "}" ]

[ "Import", "is", "the", "core", "function", "which", "handles", "importing", "the", "blocks", "from", "the", "file", "associated", "with", "the", "block", "importer", "to", "the", "database", ".", "It", "returns", "a", "channel", "on", "which", "the", "results", "will", "be", "returned", "when", "the", "operation", "has", "completed", "." ]

[ "func", "(", "msg", "*", "MsgGetBlocks", ")", "AddBlockLocatorHash", "(", "hash", "*", "chainhash", ".", "Hash", ")", "error", "{", "if", "len", "(", "msg", ".", "BlockLocatorHashes", ")", "+", "1", ">", "MaxBlockLocatorsPerMsg", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "MaxBlockLocatorsPerMsg", ")", "\n", "return", "messageError", "(", "\"", "\"", ",", "str", ")", "\n", "}", "\n\n", "msg", ".", "BlockLocatorHashes", "=", "append", "(", "msg", ".", "BlockLocatorHashes", ",", "hash", ")", "\n", "return", "nil", "\n", "}" ]

[ "AddBlockLocatorHash", "adds", "a", "new", "block", "locator", "hash", "to", "the", "message", "." ]

[ "func", "NewMsgGetBlocks", "(", "hashStop", "*", "chainhash", ".", "Hash", ")", "*", "MsgGetBlocks", "{", "return", "&", "MsgGetBlocks", "{", "ProtocolVersion", ":", "ProtocolVersion", ",", "BlockLocatorHashes", ":", "make", "(", "[", "]", "*", "chainhash", ".", "Hash", ",", "0", ",", "MaxBlockLocatorsPerMsg", ")", ",", "HashStop", ":", "*", "hashStop", ",", "}", "\n", "}" ]

[ "NewMsgGetBlocks", "returns", "a", "new", "bitcoin", "getblocks", "message", "that", "conforms", "to", "the", "Message", "interface", "using", "the", "passed", "parameters", "and", "defaults", "for", "the", "remaining", "fields", "." ]

[ "func", "(", "m", "*", "mruNonceMap", ")", "Exists", "(", "nonce", "uint64", ")", "bool", "{", "m", ".", "mtx", ".", "Lock", "(", ")", "\n", "_", ",", "exists", ":=", "m", ".", "nonceMap", "[", "nonce", "]", "\n", "m", ".", "mtx", ".", "Unlock", "(", ")", "\n\n", "return", "exists", "\n", "}" ]

[ "Exists", "returns", "whether", "or", "not", "the", "passed", "nonce", "is", "in", "the", "map", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "m", "*", "mruNonceMap", ")", "Add", "(", "nonce", "uint64", ")", "{", "m", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "mtx", ".", "Unlock", "(", ")", "\n\n", "// When the limit is zero, nothing can be added to the map, so just", "// return.", "if", "m", ".", "limit", "==", "0", "{", "return", "\n", "}", "\n\n", "// When the entry already exists move it to the front of the list", "// thereby marking it most recently used.", "if", "node", ",", "exists", ":=", "m", ".", "nonceMap", "[", "nonce", "]", ";", "exists", "{", "m", ".", "nonceList", ".", "MoveToFront", "(", "node", ")", "\n", "return", "\n", "}", "\n\n", "// Evict the least recently used entry (back of the list) if the the new", "// entry would exceed the size limit for the map. Also reuse the list", "// node so a new one doesn't have to be allocated.", "if", "uint", "(", "len", "(", "m", ".", "nonceMap", ")", ")", "+", "1", ">", "m", ".", "limit", "{", "node", ":=", "m", ".", "nonceList", ".", "Back", "(", ")", "\n", "lru", ":=", "node", ".", "Value", ".", "(", "uint64", ")", "\n\n", "// Evict least recently used item.", "delete", "(", "m", ".", "nonceMap", ",", "lru", ")", "\n\n", "// Reuse the list node of the item that was just evicted for the", "// new item.", "node", ".", "Value", "=", "nonce", "\n", "m", ".", "nonceList", ".", "MoveToFront", "(", "node", ")", "\n", "m", ".", "nonceMap", "[", "nonce", "]", "=", "node", "\n", "return", "\n", "}", "\n\n", "// The limit hasn't been reached yet, so just add the new item.", "node", ":=", "m", ".", "nonceList", ".", "PushFront", "(", "nonce", ")", "\n", "m", ".", "nonceMap", "[", "nonce", "]", "=", "node", "\n", "}" ]

[ "Add", "adds", "the", "passed", "nonce", "to", "the", "map", "and", "handles", "eviction", "of", "the", "oldest", "item", "if", "adding", "the", "new", "item", "would", "exceed", "the", "max", "limit", ".", "Adding", "an", "existing", "item", "makes", "it", "the", "most", "recently", "used", "item", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "NewTxSigHashes", "(", "tx", "*", "wire", ".", "MsgTx", ")", "*", "TxSigHashes", "{", "return", "&", "TxSigHashes", "{", "HashPrevOuts", ":", "calcHashPrevOuts", "(", "tx", ")", ",", "HashSequence", ":", "calcHashSequence", "(", "tx", ")", ",", "HashOutputs", ":", "calcHashOutputs", "(", "tx", ")", ",", "}", "\n", "}" ]

[ "NewTxSigHashes", "computes", "and", "returns", "the", "cached", "sighashes", "of", "the", "given", "transaction", "." ]

[ "func", "NewHashCache", "(", "maxSize", "uint", ")", "*", "HashCache", "{", "return", "&", "HashCache", "{", "sigHashes", ":", "make", "(", "map", "[", "chainhash", ".", "Hash", "]", "*", "TxSigHashes", ",", "maxSize", ")", ",", "}", "\n", "}" ]

[ "NewHashCache", "returns", "a", "new", "instance", "of", "the", "HashCache", "given", "a", "maximum", "number", "of", "entries", "which", "may", "exist", "within", "it", "at", "anytime", "." ]

[ "func", "(", "h", "*", "HashCache", ")", "AddSigHashes", "(", "tx", "*", "wire", ".", "MsgTx", ")", "{", "h", ".", "Lock", "(", ")", "\n", "h", ".", "sigHashes", "[", "tx", ".", "TxHash", "(", ")", "]", "=", "NewTxSigHashes", "(", "tx", ")", "\n", "h", ".", "Unlock", "(", ")", "\n", "}" ]

[ "AddSigHashes", "computes", "then", "adds", "the", "partial", "sighashes", "for", "the", "passed", "transaction", "." ]

[ "func", "(", "h", "*", "HashCache", ")", "ContainsHashes", "(", "txid", "*", "chainhash", ".", "Hash", ")", "bool", "{", "h", ".", "RLock", "(", ")", "\n", "_", ",", "found", ":=", "h", ".", "sigHashes", "[", "*", "txid", "]", "\n", "h", ".", "RUnlock", "(", ")", "\n\n", "return", "found", "\n", "}" ]

[ "ContainsHashes", "returns", "true", "if", "the", "partial", "sighashes", "for", "the", "passed", "transaction", "currently", "exist", "within", "the", "HashCache", "and", "false", "otherwise", "." ]

[ "func", "(", "h", "*", "HashCache", ")", "GetSigHashes", "(", "txid", "*", "chainhash", ".", "Hash", ")", "(", "*", "TxSigHashes", ",", "bool", ")", "{", "h", ".", "RLock", "(", ")", "\n", "item", ",", "found", ":=", "h", ".", "sigHashes", "[", "*", "txid", "]", "\n", "h", ".", "RUnlock", "(", ")", "\n\n", "return", "item", ",", "found", "\n", "}" ]

[ "GetSigHashes", "possibly", "returns", "the", "previously", "cached", "partial", "sighashes", "for", "the", "passed", "transaction", ".", "This", "function", "also", "returns", "an", "additional", "boolean", "value", "indicating", "if", "the", "sighashes", "for", "the", "passed", "transaction", "were", "found", "to", "be", "present", "within", "the", "HashCache", "." ]

[ "func", "(", "h", "*", "HashCache", ")", "PurgeSigHashes", "(", "txid", "*", "chainhash", ".", "Hash", ")", "{", "h", ".", "Lock", "(", ")", "\n", "delete", "(", "h", ".", "sigHashes", ",", "*", "txid", ")", "\n", "h", ".", "Unlock", "(", ")", "\n", "}" ]

[ "PurgeSigHashes", "removes", "all", "partial", "sighashes", "from", "the", "HashCache", "belonging", "to", "the", "passed", "transaction", "." ]

[ "func", "getChildDevice", "(", "d", "*", "device", ",", "deviceType", "string", ")", "*", "device", "{", "for", "i", ":=", "range", "d", ".", "DeviceList", ".", "Device", "{", "if", "d", ".", "DeviceList", ".", "Device", "[", "i", "]", ".", "DeviceType", "==", "deviceType", "{", "return", "&", "d", ".", "DeviceList", ".", "Device", "[", "i", "]", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "getChildDevice", "searches", "the", "children", "of", "device", "for", "a", "device", "with", "the", "given", "type", "." ]

[ "func", "getChildService", "(", "d", "*", "device", ",", "serviceType", "string", ")", "*", "service", "{", "for", "i", ":=", "range", "d", ".", "ServiceList", ".", "Service", "{", "if", "d", ".", "ServiceList", ".", "Service", "[", "i", "]", ".", "ServiceType", "==", "serviceType", "{", "return", "&", "d", ".", "ServiceList", ".", "Service", "[", "i", "]", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "getChildDevice", "searches", "the", "service", "list", "of", "device", "for", "a", "service", "with", "the", "given", "type", "." ]

[ "func", "getOurIP", "(", ")", "(", "ip", "string", ",", "err", "error", ")", "{", "hostname", ",", "err", ":=", "os", ".", "Hostname", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "net", ".", "LookupCNAME", "(", "hostname", ")", "\n", "}" ]

[ "getOurIP", "returns", "a", "best", "guess", "at", "what", "the", "local", "IP", "is", "." ]

[ "func", "soapRequest", "(", "url", ",", "function", ",", "message", "string", ")", "(", "replyXML", "[", "]", "byte", ",", "err", "error", ")", "{", "fullMessage", ":=", "\"", "\\\"", "\\\"", "\"", "+", "\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\r", "\\n", "\"", "+", "\"", "\"", "+", "message", "+", "\"", "\"", "\n\n", "req", ",", "err", ":=", "http", ".", "NewRequest", "(", "\"", "\"", ",", "url", ",", "strings", ".", "NewReader", "(", "fullMessage", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\\\"", "\\\"", "\"", ")", "\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "//req.Header.Set(\"Transfer-Encoding\", \"chunked\")", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\\\"", "\"", "+", "function", "+", "\"", "\\\"", "\"", ")", "\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "r", ",", "err", ":=", "http", ".", "DefaultClient", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "r", ".", "Body", "!=", "nil", "{", "defer", "r", ".", "Body", ".", "Close", "(", ")", "\n", "}", "\n\n", "if", "r", ".", "StatusCode", ">=", "400", "{", "// log.Stderr(function, r.StatusCode)", "err", "=", "errors", ".", "New", "(", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "r", ".", "StatusCode", ")", "+", "\"", "\"", "+", "function", ")", "\n", "r", "=", "nil", "\n", "return", "\n", "}", "\n", "var", "reply", "soapEnvelope", "\n", "err", "=", "xml", ".", "NewDecoder", "(", "r", ".", "Body", ")", ".", "Decode", "(", "&", "reply", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "reply", ".", "Body", ".", "Data", ",", "nil", "\n", "}" ]

[ "soapRequests", "performs", "a", "soap", "request", "with", "the", "given", "parameters", "and", "returns", "the", "xml", "replied", "stripped", "of", "the", "soap", "headers", ".", "in", "the", "case", "that", "the", "request", "is", "unsuccessful", "the", "an", "error", "is", "returned", "." ]

[ "func", "(", "n", "*", "upnpNAT", ")", "GetExternalAddress", "(", ")", "(", "addr", "net", ".", "IP", ",", "err", "error", ")", "{", "message", ":=", "\"", "\\\"", "\\\"", "\\r", "\\n", "\"", "\n", "response", ",", "err", ":=", "soapRequest", "(", "n", ".", "serviceURL", ",", "\"", "\"", ",", "message", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "reply", "getExternalIPAddressResponse", "\n", "err", "=", "xml", ".", "Unmarshal", "(", "response", ",", "&", "reply", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "addr", "=", "net", ".", "ParseIP", "(", "reply", ".", "ExternalIPAddress", ")", "\n", "if", "addr", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "addr", ",", "nil", "\n", "}" ]

[ "GetExternalAddress", "implements", "the", "NAT", "interface", "by", "fetching", "the", "external", "IP", "from", "the", "UPnP", "router", "." ]

[ "func", "(", "n", "*", "upnpNAT", ")", "AddPortMapping", "(", "protocol", "string", ",", "externalPort", ",", "internalPort", "int", ",", "description", "string", ",", "timeout", "int", ")", "(", "mappedExternalPort", "int", ",", "err", "error", ")", "{", "// A single concatenation would break ARM compilation.", "message", ":=", "\"", "\\\"", "\\\"", "\\r", "\\n", "\"", "+", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "externalPort", ")", "\n", "message", "+=", "\"", "\"", "+", "strings", ".", "ToUpper", "(", "protocol", ")", "+", "\"", "\"", "\n", "message", "+=", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "internalPort", ")", "+", "\"", "\"", "+", "\"", "\"", "+", "n", ".", "ourIP", "+", "\"", "\"", "+", "\"", "\"", "\n", "message", "+=", "description", "+", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "timeout", ")", "+", "\"", "\"", "\n\n", "response", ",", "err", ":=", "soapRequest", "(", "n", ".", "serviceURL", ",", "\"", "\"", ",", "message", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// TODO: check response to see if the port was forwarded", "// If the port was not wildcard we don't get an reply with the port in", "// it. Not sure about wildcard yet. miniupnpc just checks for error", "// codes here.", "mappedExternalPort", "=", "externalPort", "\n", "_", "=", "response", "\n", "return", "\n", "}" ]

[ "AddPortMapping", "implements", "the", "NAT", "interface", "by", "setting", "up", "a", "port", "forwarding", "from", "the", "UPnP", "router", "to", "the", "local", "machine", "with", "the", "given", "ports", "and", "protocol", "." ]

[ "func", "(", "n", "*", "upnpNAT", ")", "DeletePortMapping", "(", "protocol", "string", ",", "externalPort", ",", "internalPort", "int", ")", "(", "err", "error", ")", "{", "message", ":=", "\"", "\\\"", "\\\"", "\\r", "\\n", "\"", "+", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "externalPort", ")", "+", "\"", "\"", "+", "strings", ".", "ToUpper", "(", "protocol", ")", "+", "\"", "\"", "+", "\"", "\"", "\n\n", "response", ",", "err", ":=", "soapRequest", "(", "n", ".", "serviceURL", ",", "\"", "\"", ",", "message", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// TODO: check response to see if the port was deleted", "// log.Println(message, response)", "_", "=", "response", "\n", "return", "\n", "}" ]

[ "DeletePortMapping", "implements", "the", "NAT", "interface", "by", "removing", "up", "a", "port", "forwarding", "from", "the", "UPnP", "router", "to", "the", "local", "machine", "with", "the", "given", "ports", "and", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "speedMonitor", "(", ")", "{", "log", ".", "Tracef", "(", "\"", "\"", ")", "\n\n", "var", "hashesPerSec", "float64", "\n", "var", "totalHashes", "uint64", "\n", "ticker", ":=", "time", ".", "NewTicker", "(", "time", ".", "Second", "*", "hpsUpdateSecs", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n\n", "out", ":", "for", "{", "select", "{", "// Periodic updates from the workers with how many hashes they", "// have performed.", "case", "numHashes", ":=", "<-", "m", ".", "updateHashes", ":", "totalHashes", "+=", "numHashes", "\n\n", "// Time to update the hashes per second.", "case", "<-", "ticker", ".", "C", ":", "curHashesPerSec", ":=", "float64", "(", "totalHashes", ")", "/", "hpsUpdateSecs", "\n", "if", "hashesPerSec", "==", "0", "{", "hashesPerSec", "=", "curHashesPerSec", "\n", "}", "\n", "hashesPerSec", "=", "(", "hashesPerSec", "+", "curHashesPerSec", ")", "/", "2", "\n", "totalHashes", "=", "0", "\n", "if", "hashesPerSec", "!=", "0", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "hashesPerSec", "/", "1000", ")", "\n", "}", "\n\n", "// Request for the number of hashes per second.", "case", "m", ".", "queryHashesPerSec", "<-", "hashesPerSec", ":", "// Nothing to do.", "case", "<-", "m", ".", "speedMonitorQuit", ":", "break", "out", "\n", "}", "\n", "}", "\n\n", "m", ".", "wg", ".", "Done", "(", ")", "\n", "log", ".", "Tracef", "(", "\"", "\"", ")", "\n", "}" ]

[ "speedMonitor", "handles", "tracking", "the", "number", "of", "hashes", "per", "second", "the", "mining", "process", "is", "performing", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "submitBlock", "(", "block", "*", "btcutil", ".", "Block", ")", "bool", "{", "m", ".", "submitBlockLock", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "submitBlockLock", ".", "Unlock", "(", ")", "\n\n", "// Ensure the block is not stale since a new block could have shown up", "// while the solution was being found. Typically that condition is", "// detected and all work on the stale block is halted to start work on", "// a new block, but the check only happens periodically, so it is", "// possible a block was found and submitted in between.", "msgBlock", ":=", "block", ".", "MsgBlock", "(", ")", "\n", "if", "!", "msgBlock", ".", "Header", ".", "PrevBlock", ".", "IsEqual", "(", "&", "m", ".", "g", ".", "BestSnapshot", "(", ")", ".", "Hash", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", "+", "\"", "\"", ",", "msgBlock", ".", "Header", ".", "PrevBlock", ")", "\n", "return", "false", "\n", "}", "\n\n", "// Process this block using the same rules as blocks coming from other", "// nodes. This will in turn relay it to the network like normal.", "isOrphan", ",", "err", ":=", "m", ".", "cfg", ".", "ProcessBlock", "(", "block", ",", "blockchain", ".", "BFNone", ")", "\n", "if", "err", "!=", "nil", "{", "// Anything other than a rule violation is an unexpected error,", "// so log that error as an internal error.", "if", "_", ",", "ok", ":=", "err", ".", "(", "blockchain", ".", "RuleError", ")", ";", "!", "ok", "{", "log", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "if", "isOrphan", "{", "log", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "false", "\n", "}", "\n\n", "// The block was accepted.", "coinbaseTx", ":=", "block", ".", "MsgBlock", "(", ")", ".", "Transactions", "[", "0", "]", ".", "TxOut", "[", "0", "]", "\n", "log", ".", "Infof", "(", "\"", "\"", "+", "\"", "\"", ",", "block", ".", "Hash", "(", ")", ",", "btcutil", ".", "Amount", "(", "coinbaseTx", ".", "Value", ")", ")", "\n", "return", "true", "\n", "}" ]

[ "submitBlock", "submits", "the", "passed", "block", "to", "network", "after", "ensuring", "it", "passes", "all", "of", "the", "consensus", "validation", "rules", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "solveBlock", "(", "msgBlock", "*", "wire", ".", "MsgBlock", ",", "blockHeight", "int32", ",", "ticker", "*", "time", ".", "Ticker", ",", "quit", "chan", "struct", "{", "}", ")", "bool", "{", "// Choose a random extra nonce offset for this block template and", "// worker.", "enOffset", ",", "err", ":=", "wire", ".", "RandomUint64", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "enOffset", "=", "0", "\n", "}", "\n\n", "// Create some convenience variables.", "header", ":=", "&", "msgBlock", ".", "Header", "\n", "targetDifficulty", ":=", "blockchain", ".", "CompactToBig", "(", "header", ".", "Bits", ")", "\n\n", "// Initial state.", "lastGenerated", ":=", "time", ".", "Now", "(", ")", "\n", "lastTxUpdate", ":=", "m", ".", "g", ".", "TxSource", "(", ")", ".", "LastUpdated", "(", ")", "\n", "hashesCompleted", ":=", "uint64", "(", "0", ")", "\n\n", "// Note that the entire extra nonce range is iterated and the offset is", "// added relying on the fact that overflow will wrap around 0 as", "// provided by the Go spec.", "for", "extraNonce", ":=", "uint64", "(", "0", ")", ";", "extraNonce", "<", "maxExtraNonce", ";", "extraNonce", "++", "{", "// Update the extra nonce in the block template with the", "// new value by regenerating the coinbase script and", "// setting the merkle root to the new value.", "m", ".", "g", ".", "UpdateExtraNonce", "(", "msgBlock", ",", "blockHeight", ",", "extraNonce", "+", "enOffset", ")", "\n\n", "// Search through the entire nonce range for a solution while", "// periodically checking for early quit and stale block", "// conditions along with updates to the speed monitor.", "for", "i", ":=", "uint32", "(", "0", ")", ";", "i", "<=", "maxNonce", ";", "i", "++", "{", "select", "{", "case", "<-", "quit", ":", "return", "false", "\n\n", "case", "<-", "ticker", ".", "C", ":", "m", ".", "updateHashes", "<-", "hashesCompleted", "\n", "hashesCompleted", "=", "0", "\n\n", "// The current block is stale if the best block", "// has changed.", "best", ":=", "m", ".", "g", ".", "BestSnapshot", "(", ")", "\n", "if", "!", "header", ".", "PrevBlock", ".", "IsEqual", "(", "&", "best", ".", "Hash", ")", "{", "return", "false", "\n", "}", "\n\n", "// The current block is stale if the memory pool", "// has been updated since the block template was", "// generated and it has been at least one", "// minute.", "if", "lastTxUpdate", "!=", "m", ".", "g", ".", "TxSource", "(", ")", ".", "LastUpdated", "(", ")", "&&", "time", ".", "Now", "(", ")", ".", "After", "(", "lastGenerated", ".", "Add", "(", "time", ".", "Minute", ")", ")", "{", "return", "false", "\n", "}", "\n\n", "m", ".", "g", ".", "UpdateBlockTime", "(", "msgBlock", ")", "\n\n", "default", ":", "// Non-blocking select to fall through", "}", "\n\n", "// Update the nonce and hash the block header. Each", "// hash is actually a double sha256 (two hashes), so", "// increment the number of hashes completed for each", "// attempt accordingly.", "header", ".", "Nonce", "=", "i", "\n", "hash", ":=", "header", ".", "BlockHash", "(", ")", "\n", "hashesCompleted", "+=", "2", "\n\n", "// The block is solved when the new block hash is less", "// than the target difficulty. Yay!", "if", "blockchain", ".", "HashToBig", "(", "&", "hash", ")", ".", "Cmp", "(", "targetDifficulty", ")", "<=", "0", "{", "m", ".", "updateHashes", "<-", "hashesCompleted", "\n", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "solveBlock", "attempts", "to", "find", "some", "combination", "of", "a", "nonce", "extra", "nonce", "and", "current", "timestamp", "which", "makes", "the", "passed", "block", "hash", "to", "a", "value", "less", "than", "the", "target", "difficulty", ".", "The", "timestamp", "is", "updated", "periodically", "and", "the", "passed", "block", "is", "modified", "with", "all", "tweaks", "during", "this", "process", ".", "This", "means", "that", "when", "the", "function", "returns", "true", "the", "block", "is", "ready", "for", "submission", ".", "This", "function", "will", "return", "early", "with", "false", "when", "conditions", "that", "trigger", "a", "stale", "block", "such", "as", "a", "new", "block", "showing", "up", "or", "periodically", "when", "there", "are", "new", "transactions", "and", "enough", "time", "has", "elapsed", "without", "finding", "a", "solution", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "generateBlocks", "(", "quit", "chan", "struct", "{", "}", ")", "{", "log", ".", "Tracef", "(", "\"", "\"", ")", "\n\n", "// Start a ticker which is used to signal checks for stale work and", "// updates to the speed monitor.", "ticker", ":=", "time", ".", "NewTicker", "(", "time", ".", "Second", "*", "hashUpdateSecs", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n", "out", ":", "for", "{", "// Quit when the miner is stopped.", "select", "{", "case", "<-", "quit", ":", "break", "out", "\n", "default", ":", "// Non-blocking select to fall through", "}", "\n\n", "// Wait until there is a connection to at least one other peer", "// since there is no way to relay a found block or receive", "// transactions to work on when there are no connected peers.", "if", "m", ".", "cfg", ".", "ConnectedCount", "(", ")", "==", "0", "{", "time", ".", "Sleep", "(", "time", ".", "Second", ")", "\n", "continue", "\n", "}", "\n\n", "// No point in searching for a solution before the chain is", "// synced. Also, grab the same lock as used for block", "// submission, since the current block will be changing and", "// this would otherwise end up building a new block template on", "// a block that is in the process of becoming stale.", "m", ".", "submitBlockLock", ".", "Lock", "(", ")", "\n", "curHeight", ":=", "m", ".", "g", ".", "BestSnapshot", "(", ")", ".", "Height", "\n", "if", "curHeight", "!=", "0", "&&", "!", "m", ".", "cfg", ".", "IsCurrent", "(", ")", "{", "m", ".", "submitBlockLock", ".", "Unlock", "(", ")", "\n", "time", ".", "Sleep", "(", "time", ".", "Second", ")", "\n", "continue", "\n", "}", "\n\n", "// Choose a payment address at random.", "rand", ".", "Seed", "(", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", "\n", "payToAddr", ":=", "m", ".", "cfg", ".", "MiningAddrs", "[", "rand", ".", "Intn", "(", "len", "(", "m", ".", "cfg", ".", "MiningAddrs", ")", ")", "]", "\n\n", "// Create a new block template using the available transactions", "// in the memory pool as a source of transactions to potentially", "// include in the block.", "template", ",", "err", ":=", "m", ".", "g", ".", "NewBlockTemplate", "(", "payToAddr", ")", "\n", "m", ".", "submitBlockLock", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "errStr", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "log", ".", "Errorf", "(", "errStr", ")", "\n", "continue", "\n", "}", "\n\n", "// Attempt to solve the block. The function will exit early", "// with false when conditions that trigger a stale block, so", "// a new block template can be generated. When the return is", "// true a solution was found, so submit the solved block.", "if", "m", ".", "solveBlock", "(", "template", ".", "Block", ",", "curHeight", "+", "1", ",", "ticker", ",", "quit", ")", "{", "block", ":=", "btcutil", ".", "NewBlock", "(", "template", ".", "Block", ")", "\n", "m", ".", "submitBlock", "(", "block", ")", "\n", "}", "\n", "}", "\n\n", "m", ".", "workerWg", ".", "Done", "(", ")", "\n", "log", ".", "Tracef", "(", "\"", "\"", ")", "\n", "}" ]

[ "generateBlocks", "is", "a", "worker", "that", "is", "controlled", "by", "the", "miningWorkerController", ".", "It", "is", "self", "contained", "in", "that", "it", "creates", "block", "templates", "and", "attempts", "to", "solve", "them", "while", "detecting", "when", "it", "is", "performing", "stale", "work", "and", "reacting", "accordingly", "by", "generating", "a", "new", "block", "template", ".", "When", "a", "block", "is", "solved", "it", "is", "submitted", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "miningWorkerController", "(", ")", "{", "// launchWorkers groups common code to launch a specified number of", "// workers for generating blocks.", "var", "runningWorkers", "[", "]", "chan", "struct", "{", "}", "\n", "launchWorkers", ":=", "func", "(", "numWorkers", "uint32", ")", "{", "for", "i", ":=", "uint32", "(", "0", ")", ";", "i", "<", "numWorkers", ";", "i", "++", "{", "quit", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "runningWorkers", "=", "append", "(", "runningWorkers", ",", "quit", ")", "\n\n", "m", ".", "workerWg", ".", "Add", "(", "1", ")", "\n", "go", "m", ".", "generateBlocks", "(", "quit", ")", "\n", "}", "\n", "}", "\n\n", "// Launch the current number of workers by default.", "runningWorkers", "=", "make", "(", "[", "]", "chan", "struct", "{", "}", ",", "0", ",", "m", ".", "numWorkers", ")", "\n", "launchWorkers", "(", "m", ".", "numWorkers", ")", "\n\n", "out", ":", "for", "{", "select", "{", "// Update the number of running workers.", "case", "<-", "m", ".", "updateNumWorkers", ":", "// No change.", "numRunning", ":=", "uint32", "(", "len", "(", "runningWorkers", ")", ")", "\n", "if", "m", ".", "numWorkers", "==", "numRunning", "{", "continue", "\n", "}", "\n\n", "// Add new workers.", "if", "m", ".", "numWorkers", ">", "numRunning", "{", "launchWorkers", "(", "m", ".", "numWorkers", "-", "numRunning", ")", "\n", "continue", "\n", "}", "\n\n", "// Signal the most recently created goroutines to exit.", "for", "i", ":=", "numRunning", "-", "1", ";", "i", ">=", "m", ".", "numWorkers", ";", "i", "--", "{", "close", "(", "runningWorkers", "[", "i", "]", ")", "\n", "runningWorkers", "[", "i", "]", "=", "nil", "\n", "runningWorkers", "=", "runningWorkers", "[", ":", "i", "]", "\n", "}", "\n\n", "case", "<-", "m", ".", "quit", ":", "for", "_", ",", "quit", ":=", "range", "runningWorkers", "{", "close", "(", "quit", ")", "\n", "}", "\n", "break", "out", "\n", "}", "\n", "}", "\n\n", "// Wait until all workers shut down to stop the speed monitor since", "// they rely on being able to send updates to it.", "m", ".", "workerWg", ".", "Wait", "(", ")", "\n", "close", "(", "m", ".", "speedMonitorQuit", ")", "\n", "m", ".", "wg", ".", "Done", "(", ")", "\n", "}" ]

[ "miningWorkerController", "launches", "the", "worker", "goroutines", "that", "are", "used", "to", "generate", "block", "templates", "and", "solve", "them", ".", "It", "also", "provides", "the", "ability", "to", "dynamically", "adjust", "the", "number", "of", "running", "worker", "goroutines", ".", "It", "must", "be", "run", "as", "a", "goroutine", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "Start", "(", ")", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n\n", "// Nothing to do if the miner is already running or if running in", "// discrete mode (using GenerateNBlocks).", "if", "m", ".", "started", "||", "m", ".", "discreteMining", "{", "return", "\n", "}", "\n\n", "m", ".", "quit", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "m", ".", "speedMonitorQuit", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "m", ".", "wg", ".", "Add", "(", "2", ")", "\n", "go", "m", ".", "speedMonitor", "(", ")", "\n", "go", "m", ".", "miningWorkerController", "(", ")", "\n\n", "m", ".", "started", "=", "true", "\n", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "}" ]

[ "Start", "begins", "the", "CPU", "mining", "process", "as", "well", "as", "the", "speed", "monitor", "used", "to", "track", "hashing", "metrics", ".", "Calling", "this", "function", "when", "the", "CPU", "miner", "has", "already", "been", "started", "will", "have", "no", "effect", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "Stop", "(", ")", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n\n", "// Nothing to do if the miner is not currently running or if running in", "// discrete mode (using GenerateNBlocks).", "if", "!", "m", ".", "started", "||", "m", ".", "discreteMining", "{", "return", "\n", "}", "\n\n", "close", "(", "m", ".", "quit", ")", "\n", "m", ".", "wg", ".", "Wait", "(", ")", "\n", "m", ".", "started", "=", "false", "\n", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "}" ]

[ "Stop", "gracefully", "stops", "the", "mining", "process", "by", "signalling", "all", "workers", "and", "the", "speed", "monitor", "to", "quit", ".", "Calling", "this", "function", "when", "the", "CPU", "miner", "has", "not", "already", "been", "started", "will", "have", "no", "effect", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "IsMining", "(", ")", "bool", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n\n", "return", "m", ".", "started", "\n", "}" ]

[ "IsMining", "returns", "whether", "or", "not", "the", "CPU", "miner", "has", "been", "started", "and", "is", "therefore", "currenting", "mining", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "HashesPerSecond", "(", ")", "float64", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n\n", "// Nothing to do if the miner is not currently running.", "if", "!", "m", ".", "started", "{", "return", "0", "\n", "}", "\n\n", "return", "<-", "m", ".", "queryHashesPerSec", "\n", "}" ]

[ "HashesPerSecond", "returns", "the", "number", "of", "hashes", "per", "second", "the", "mining", "process", "is", "performing", ".", "0", "is", "returned", "if", "the", "miner", "is", "not", "currently", "running", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "SetNumWorkers", "(", "numWorkers", "int32", ")", "{", "if", "numWorkers", "==", "0", "{", "m", ".", "Stop", "(", ")", "\n", "}", "\n\n", "// Don't lock until after the first check since Stop does its own", "// locking.", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n\n", "// Use default if provided value is negative.", "if", "numWorkers", "<", "0", "{", "m", ".", "numWorkers", "=", "defaultNumWorkers", "\n", "}", "else", "{", "m", ".", "numWorkers", "=", "uint32", "(", "numWorkers", ")", "\n", "}", "\n\n", "// When the miner is already running, notify the controller about the", "// the change.", "if", "m", ".", "started", "{", "m", ".", "updateNumWorkers", "<-", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}" ]

[ "SetNumWorkers", "sets", "the", "number", "of", "workers", "to", "create", "which", "solve", "blocks", ".", "Any", "negative", "values", "will", "cause", "a", "default", "number", "of", "workers", "to", "be", "used", "which", "is", "based", "on", "the", "number", "of", "processor", "cores", "in", "the", "system", ".", "A", "value", "of", "0", "will", "cause", "all", "CPU", "mining", "to", "be", "stopped", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "NumWorkers", "(", ")", "int32", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n\n", "return", "int32", "(", "m", ".", "numWorkers", ")", "\n", "}" ]

[ "NumWorkers", "returns", "the", "number", "of", "workers", "which", "are", "running", "to", "solve", "blocks", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "m", "*", "CPUMiner", ")", "GenerateNBlocks", "(", "n", "uint32", ")", "(", "[", "]", "*", "chainhash", ".", "Hash", ",", "error", ")", "{", "m", ".", "Lock", "(", ")", "\n\n", "// Respond with an error if server is already mining.", "if", "m", ".", "started", "||", "m", ".", "discreteMining", "{", "m", ".", "Unlock", "(", ")", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n\n", "m", ".", "started", "=", "true", "\n", "m", ".", "discreteMining", "=", "true", "\n\n", "m", ".", "speedMonitorQuit", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "m", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "m", ".", "speedMonitor", "(", ")", "\n\n", "m", ".", "Unlock", "(", ")", "\n\n", "log", ".", "Tracef", "(", "\"", "\"", ",", "n", ")", "\n\n", "i", ":=", "uint32", "(", "0", ")", "\n", "blockHashes", ":=", "make", "(", "[", "]", "*", "chainhash", ".", "Hash", ",", "n", ")", "\n\n", "// Start a ticker which is used to signal checks for stale work and", "// updates to the speed monitor.", "ticker", ":=", "time", ".", "NewTicker", "(", "time", ".", "Second", "*", "hashUpdateSecs", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n\n", "for", "{", "// Read updateNumWorkers in case someone tries a `setgenerate` while", "// we're generating. We can ignore it as the `generate` RPC call only", "// uses 1 worker.", "select", "{", "case", "<-", "m", ".", "updateNumWorkers", ":", "default", ":", "}", "\n\n", "// Grab the lock used for block submission, since the current block will", "// be changing and this would otherwise end up building a new block", "// template on a block that is in the process of becoming stale.", "m", ".", "submitBlockLock", ".", "Lock", "(", ")", "\n", "curHeight", ":=", "m", ".", "g", ".", "BestSnapshot", "(", ")", ".", "Height", "\n\n", "// Choose a payment address at random.", "rand", ".", "Seed", "(", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", "\n", "payToAddr", ":=", "m", ".", "cfg", ".", "MiningAddrs", "[", "rand", ".", "Intn", "(", "len", "(", "m", ".", "cfg", ".", "MiningAddrs", ")", ")", "]", "\n\n", "// Create a new block template using the available transactions", "// in the memory pool as a source of transactions to potentially", "// include in the block.", "template", ",", "err", ":=", "m", ".", "g", ".", "NewBlockTemplate", "(", "payToAddr", ")", "\n", "m", ".", "submitBlockLock", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "errStr", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "log", ".", "Errorf", "(", "errStr", ")", "\n", "continue", "\n", "}", "\n\n", "// Attempt to solve the block. The function will exit early", "// with false when conditions that trigger a stale block, so", "// a new block template can be generated. When the return is", "// true a solution was found, so submit the solved block.", "if", "m", ".", "solveBlock", "(", "template", ".", "Block", ",", "curHeight", "+", "1", ",", "ticker", ",", "nil", ")", "{", "block", ":=", "btcutil", ".", "NewBlock", "(", "template", ".", "Block", ")", "\n", "m", ".", "submitBlock", "(", "block", ")", "\n", "blockHashes", "[", "i", "]", "=", "block", ".", "Hash", "(", ")", "\n", "i", "++", "\n", "if", "i", "==", "n", "{", "log", ".", "Tracef", "(", "\"", "\"", ",", "i", ")", "\n", "m", ".", "Lock", "(", ")", "\n", "close", "(", "m", ".", "speedMonitorQuit", ")", "\n", "m", ".", "wg", ".", "Wait", "(", ")", "\n", "m", ".", "started", "=", "false", "\n", "m", ".", "discreteMining", "=", "false", "\n", "m", ".", "Unlock", "(", ")", "\n", "return", "blockHashes", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "GenerateNBlocks", "generates", "the", "requested", "number", "of", "blocks", ".", "It", "is", "self", "contained", "in", "that", "it", "creates", "block", "templates", "and", "attempts", "to", "solve", "them", "while", "detecting", "when", "it", "is", "performing", "stale", "work", "and", "reacting", "accordingly", "by", "generating", "a", "new", "block", "template", ".", "When", "a", "block", "is", "solved", "it", "is", "submitted", ".", "The", "function", "returns", "a", "list", "of", "the", "hashes", "of", "generated", "blocks", "." ]