Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "ParseDERSignature", "(", "sigStr", "[", "]", "byte", ",", "curve", "elliptic", ".", "Curve", ")", "(", "*", "Signature", ",", "error", ")", "{", "return", "parseSig", "(", "sigStr", ",", "curve", ",", "true", ")", "\n", "}" ]

[ "ParseDERSignature", "parses", "a", "signature", "in", "DER", "format", "for", "the", "curve", "type", "curve", "into", "a", "Signature", "type", ".", "If", "parsing", "according", "to", "the", "less", "strict", "BER", "format", "is", "needed", "use", "ParseSignature", "." ]

[ "func", "canonicalizeInt", "(", "val", "*", "big", ".", "Int", ")", "[", "]", "byte", "{", "b", ":=", "val", ".", "Bytes", "(", ")", "\n", "if", "len", "(", "b", ")", "==", "0", "{", "b", "=", "[", "]", "byte", "{", "0x00", "}", "\n", "}", "\n", "if", "b", "[", "0", "]", "&", "0x80", "!=", "0", "{", "paddedBytes", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "b", ")", "+", "1", ")", "\n", "copy", "(", "paddedBytes", "[", "1", ":", "]", ",", "b", ")", "\n", "b", "=", "paddedBytes", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "canonicalizeInt", "returns", "the", "bytes", "for", "the", "passed", "big", "integer", "adjusted", "as", "necessary", "to", "ensure", "that", "a", "big", "-", "endian", "encoded", "integer", "can", "t", "possibly", "be", "misinterpreted", "as", "a", "negative", "number", ".", "This", "can", "happen", "when", "the", "most", "significant", "bit", "is", "set", "so", "it", "is", "padded", "by", "a", "leading", "zero", "byte", "in", "this", "case", ".", "Also", "the", "returned", "bytes", "will", "have", "at", "least", "a", "single", "byte", "when", "the", "passed", "value", "is", "0", ".", "This", "is", "required", "for", "DER", "encoding", "." ]

[ "func", "RecoverCompact", "(", "curve", "*", "KoblitzCurve", ",", "signature", ",", "hash", "[", "]", "byte", ")", "(", "*", "PublicKey", ",", "bool", ",", "error", ")", "{", "bitlen", ":=", "(", "curve", ".", "BitSize", "+", "7", ")", "/", "8", "\n", "if", "len", "(", "signature", ")", "!=", "1", "+", "bitlen", "*", "2", "{", "return", "nil", ",", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "iteration", ":=", "int", "(", "(", "signature", "[", "0", "]", "-", "27", ")", "&", "^", "byte", "(", "4", ")", ")", "\n\n", "// format is <header byte><bitlen R><bitlen S>", "sig", ":=", "&", "Signature", "{", "R", ":", "new", "(", "big", ".", "Int", ")", ".", "SetBytes", "(", "signature", "[", "1", ":", "bitlen", "+", "1", "]", ")", ",", "S", ":", "new", "(", "big", ".", "Int", ")", ".", "SetBytes", "(", "signature", "[", "bitlen", "+", "1", ":", "]", ")", ",", "}", "\n", "// The iteration used here was encoded", "key", ",", "err", ":=", "recoverKeyFromSignature", "(", "curve", ",", "sig", ",", "hash", ",", "iteration", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "return", "key", ",", "(", "(", "signature", "[", "0", "]", "-", "27", ")", "&", "4", ")", "==", "4", ",", "nil", "\n", "}" ]

[ "RecoverCompact", "verifies", "the", "compact", "signature", "signature", "of", "hash", "for", "the", "Koblitz", "curve", "in", "curve", ".", "If", "the", "signature", "matches", "then", "the", "recovered", "public", "key", "will", "be", "returned", "as", "well", "as", "a", "boolen", "if", "the", "original", "key", "was", "compressed", "or", "not", "else", "an", "error", "will", "be", "returned", "." ]

[ "func", "signRFC6979", "(", "privateKey", "*", "PrivateKey", ",", "hash", "[", "]", "byte", ")", "(", "*", "Signature", ",", "error", ")", "{", "privkey", ":=", "privateKey", ".", "ToECDSA", "(", ")", "\n", "N", ":=", "S256", "(", ")", ".", "N", "\n", "halfOrder", ":=", "S256", "(", ")", ".", "halfOrder", "\n", "k", ":=", "nonceRFC6979", "(", "privkey", ".", "D", ",", "hash", ")", "\n", "inv", ":=", "new", "(", "big", ".", "Int", ")", ".", "ModInverse", "(", "k", ",", "N", ")", "\n", "r", ",", "_", ":=", "privkey", ".", "Curve", ".", "ScalarBaseMult", "(", "k", ".", "Bytes", "(", ")", ")", "\n", "r", ".", "Mod", "(", "r", ",", "N", ")", "\n\n", "if", "r", ".", "Sign", "(", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "e", ":=", "hashToInt", "(", "hash", ",", "privkey", ".", "Curve", ")", "\n", "s", ":=", "new", "(", "big", ".", "Int", ")", ".", "Mul", "(", "privkey", ".", "D", ",", "r", ")", "\n", "s", ".", "Add", "(", "s", ",", "e", ")", "\n", "s", ".", "Mul", "(", "s", ",", "inv", ")", "\n", "s", ".", "Mod", "(", "s", ",", "N", ")", "\n\n", "if", "s", ".", "Cmp", "(", "halfOrder", ")", "==", "1", "{", "s", ".", "Sub", "(", "N", ",", "s", ")", "\n", "}", "\n", "if", "s", ".", "Sign", "(", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "Signature", "{", "R", ":", "r", ",", "S", ":", "s", "}", ",", "nil", "\n", "}" ]

[ "signRFC6979", "generates", "a", "deterministic", "ECDSA", "signature", "according", "to", "RFC", "6979", "and", "BIP", "62", "." ]

[ "func", "mac", "(", "alg", "func", "(", ")", "hash", ".", "Hash", ",", "k", ",", "m", "[", "]", "byte", ")", "[", "]", "byte", "{", "h", ":=", "hmac", ".", "New", "(", "alg", ",", "k", ")", "\n", "h", ".", "Write", "(", "m", ")", "\n", "return", "h", ".", "Sum", "(", "nil", ")", "\n", "}" ]

[ "mac", "returns", "an", "HMAC", "of", "the", "given", "key", "and", "message", "." ]

[ "func", "(", "pq", "*", "txPriorityQueue", ")", "Less", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "pq", ".", "lessFunc", "(", "pq", ",", "i", ",", "j", ")", "\n", "}" ]

[ "Less", "returns", "whether", "the", "item", "in", "the", "priority", "queue", "with", "index", "i", "should", "sort", "before", "the", "item", "with", "index", "j", "by", "deferring", "to", "the", "assigned", "less", "function", ".", "It", "is", "part", "of", "the", "heap", ".", "Interface", "implementation", "." ]

[ "func", "(", "pq", "*", "txPriorityQueue", ")", "Swap", "(", "i", ",", "j", "int", ")", "{", "pq", ".", "items", "[", "i", "]", ",", "pq", ".", "items", "[", "j", "]", "=", "pq", ".", "items", "[", "j", "]", ",", "pq", ".", "items", "[", "i", "]", "\n", "}" ]

[ "Swap", "swaps", "the", "items", "at", "the", "passed", "indices", "in", "the", "priority", "queue", ".", "It", "is", "part", "of", "the", "heap", ".", "Interface", "implementation", "." ]

[ "func", "(", "pq", "*", "txPriorityQueue", ")", "Push", "(", "x", "interface", "{", "}", ")", "{", "pq", ".", "items", "=", "append", "(", "pq", ".", "items", ",", "x", ".", "(", "*", "txPrioItem", ")", ")", "\n", "}" ]

[ "Push", "pushes", "the", "passed", "item", "onto", "the", "priority", "queue", ".", "It", "is", "part", "of", "the", "heap", ".", "Interface", "implementation", "." ]

[ "func", "txPQByPriority", "(", "pq", "*", "txPriorityQueue", ",", "i", ",", "j", "int", ")", "bool", "{", "// Using > here so that pop gives the highest priority item as opposed", "// to the lowest. Sort by priority first, then fee.", "if", "pq", ".", "items", "[", "i", "]", ".", "priority", "==", "pq", ".", "items", "[", "j", "]", ".", "priority", "{", "return", "pq", ".", "items", "[", "i", "]", ".", "feePerKB", ">", "pq", ".", "items", "[", "j", "]", ".", "feePerKB", "\n", "}", "\n", "return", "pq", ".", "items", "[", "i", "]", ".", "priority", ">", "pq", ".", "items", "[", "j", "]", ".", "priority", "\n\n", "}" ]

[ "txPQByPriority", "sorts", "a", "txPriorityQueue", "by", "transaction", "priority", "and", "then", "fees", "per", "kilobyte", "." ]

[ "func", "mergeUtxoView", "(", "viewA", "*", "blockchain", ".", "UtxoViewpoint", ",", "viewB", "*", "blockchain", ".", "UtxoViewpoint", ")", "{", "viewAEntries", ":=", "viewA", ".", "Entries", "(", ")", "\n", "for", "outpoint", ",", "entryB", ":=", "range", "viewB", ".", "Entries", "(", ")", "{", "if", "entryA", ",", "exists", ":=", "viewAEntries", "[", "outpoint", "]", ";", "!", "exists", "||", "entryA", "==", "nil", "||", "entryA", ".", "IsSpent", "(", ")", "{", "viewAEntries", "[", "outpoint", "]", "=", "entryB", "\n", "}", "\n", "}", "\n", "}" ]

[ "mergeUtxoView", "adds", "all", "of", "the", "entries", "in", "viewB", "to", "viewA", ".", "The", "result", "is", "that", "viewA", "will", "contain", "all", "of", "its", "original", "entries", "plus", "all", "of", "the", "entries", "in", "viewB", ".", "It", "will", "replace", "any", "entries", "in", "viewB", "which", "also", "exist", "in", "viewA", "if", "the", "entry", "in", "viewA", "is", "spent", "." ]

[ "func", "standardCoinbaseScript", "(", "nextBlockHeight", "int32", ",", "extraNonce", "uint64", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "txscript", ".", "NewScriptBuilder", "(", ")", ".", "AddInt64", "(", "int64", "(", "nextBlockHeight", ")", ")", ".", "AddInt64", "(", "int64", "(", "extraNonce", ")", ")", ".", "AddData", "(", "[", "]", "byte", "(", "CoinbaseFlags", ")", ")", ".", "Script", "(", ")", "\n", "}" ]

[ "standardCoinbaseScript", "returns", "a", "standard", "script", "suitable", "for", "use", "as", "the", "signature", "script", "of", "the", "coinbase", "transaction", "of", "a", "new", "block", ".", "In", "particular", "it", "starts", "with", "the", "block", "height", "that", "is", "required", "by", "version", "2", "blocks", "and", "adds", "the", "extra", "nonce", "as", "well", "as", "additional", "coinbase", "flags", "." ]

[ "func", "createCoinbaseTx", "(", "params", "*", "chaincfg", ".", "Params", ",", "coinbaseScript", "[", "]", "byte", ",", "nextBlockHeight", "int32", ",", "addr", "btcutil", ".", "Address", ")", "(", "*", "btcutil", ".", "Tx", ",", "error", ")", "{", "// Create the script to pay to the provided payment address if one was", "// specified. Otherwise create a script that allows the coinbase to be", "// redeemable by anyone.", "var", "pkScript", "[", "]", "byte", "\n", "if", "addr", "!=", "nil", "{", "var", "err", "error", "\n", "pkScript", ",", "err", "=", "txscript", ".", "PayToAddrScript", "(", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "else", "{", "var", "err", "error", "\n", "scriptBuilder", ":=", "txscript", ".", "NewScriptBuilder", "(", ")", "\n", "pkScript", ",", "err", "=", "scriptBuilder", ".", "AddOp", "(", "txscript", ".", "OP_TRUE", ")", ".", "Script", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "tx", ":=", "wire", ".", "NewMsgTx", "(", "wire", ".", "TxVersion", ")", "\n", "tx", ".", "AddTxIn", "(", "&", "wire", ".", "TxIn", "{", "// Coinbase transactions have no inputs, so previous outpoint is", "// zero hash and max index.", "PreviousOutPoint", ":", "*", "wire", ".", "NewOutPoint", "(", "&", "chainhash", ".", "Hash", "{", "}", ",", "wire", ".", "MaxPrevOutIndex", ")", ",", "SignatureScript", ":", "coinbaseScript", ",", "Sequence", ":", "wire", ".", "MaxTxInSequenceNum", ",", "}", ")", "\n", "tx", ".", "AddTxOut", "(", "&", "wire", ".", "TxOut", "{", "Value", ":", "blockchain", ".", "CalcBlockSubsidy", "(", "nextBlockHeight", ",", "params", ")", ",", "PkScript", ":", "pkScript", ",", "}", ")", "\n", "return", "btcutil", ".", "NewTx", "(", "tx", ")", ",", "nil", "\n", "}" ]

[ "createCoinbaseTx", "returns", "a", "coinbase", "transaction", "paying", "an", "appropriate", "subsidy", "based", "on", "the", "passed", "block", "height", "to", "the", "provided", "address", ".", "When", "the", "address", "is", "nil", "the", "coinbase", "transaction", "will", "instead", "be", "redeemable", "by", "anyone", ".", "See", "the", "comment", "for", "NewBlockTemplate", "for", "more", "information", "about", "why", "the", "nil", "address", "handling", "is", "useful", "." ]

[ "func", "spendTransaction", "(", "utxoView", "*", "blockchain", ".", "UtxoViewpoint", ",", "tx", "*", "btcutil", ".", "Tx", ",", "height", "int32", ")", "error", "{", "for", "_", ",", "txIn", ":=", "range", "tx", ".", "MsgTx", "(", ")", ".", "TxIn", "{", "entry", ":=", "utxoView", ".", "LookupEntry", "(", "txIn", ".", "PreviousOutPoint", ")", "\n", "if", "entry", "!=", "nil", "{", "entry", ".", "Spend", "(", ")", "\n", "}", "\n", "}", "\n\n", "utxoView", ".", "AddTxOuts", "(", "tx", ",", "height", ")", "\n", "return", "nil", "\n", "}" ]

[ "spendTransaction", "updates", "the", "passed", "view", "by", "marking", "the", "inputs", "to", "the", "passed", "transaction", "as", "spent", ".", "It", "also", "adds", "all", "outputs", "in", "the", "passed", "transaction", "which", "are", "not", "provably", "unspendable", "as", "available", "unspent", "transaction", "outputs", "." ]

[ "func", "logSkippedDeps", "(", "tx", "*", "btcutil", ".", "Tx", ",", "deps", "map", "[", "chainhash", ".", "Hash", "]", "*", "txPrioItem", ")", "{", "if", "deps", "==", "nil", "{", "return", "\n", "}", "\n\n", "for", "_", ",", "item", ":=", "range", "deps", "{", "log", ".", "Tracef", "(", "\"", "\\n", "\"", ",", "item", ".", "tx", ".", "Hash", "(", ")", ",", "tx", ".", "Hash", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "logSkippedDeps", "logs", "any", "dependencies", "which", "are", "also", "skipped", "as", "a", "result", "of", "skipping", "a", "transaction", "while", "generating", "a", "block", "template", "at", "the", "trace", "level", "." ]

[ "func", "MinimumMedianTime", "(", "chainState", "*", "blockchain", ".", "BestState", ")", "time", ".", "Time", "{", "return", "chainState", ".", "MedianTime", ".", "Add", "(", "time", ".", "Second", ")", "\n", "}" ]

[ "MinimumMedianTime", "returns", "the", "minimum", "allowed", "timestamp", "for", "a", "block", "building", "on", "the", "end", "of", "the", "provided", "best", "chain", ".", "In", "particular", "it", "is", "one", "second", "after", "the", "median", "timestamp", "of", "the", "last", "several", "blocks", "per", "the", "chain", "consensus", "rules", "." ]

[ "func", "medianAdjustedTime", "(", "chainState", "*", "blockchain", ".", "BestState", ",", "timeSource", "blockchain", ".", "MedianTimeSource", ")", "time", ".", "Time", "{", "// The timestamp for the block must not be before the median timestamp", "// of the last several blocks. Thus, choose the maximum between the", "// current time and one second after the past median time. The current", "// timestamp is truncated to a second boundary before comparison since a", "// block timestamp does not supported a precision greater than one", "// second.", "newTimestamp", ":=", "timeSource", ".", "AdjustedTime", "(", ")", "\n", "minTimestamp", ":=", "MinimumMedianTime", "(", "chainState", ")", "\n", "if", "newTimestamp", ".", "Before", "(", "minTimestamp", ")", "{", "newTimestamp", "=", "minTimestamp", "\n", "}", "\n\n", "return", "newTimestamp", "\n", "}" ]

[ "medianAdjustedTime", "returns", "the", "current", "time", "adjusted", "to", "ensure", "it", "is", "at", "least", "one", "second", "after", "the", "median", "timestamp", "of", "the", "last", "several", "blocks", "per", "the", "chain", "consensus", "rules", "." ]

[ "func", "NewBlkTmplGenerator", "(", "policy", "*", "Policy", ",", "params", "*", "chaincfg", ".", "Params", ",", "txSource", "TxSource", ",", "chain", "*", "blockchain", ".", "BlockChain", ",", "timeSource", "blockchain", ".", "MedianTimeSource", ",", "sigCache", "*", "txscript", ".", "SigCache", ",", "hashCache", "*", "txscript", ".", "HashCache", ")", "*", "BlkTmplGenerator", "{", "return", "&", "BlkTmplGenerator", "{", "policy", ":", "policy", ",", "chainParams", ":", "params", ",", "txSource", ":", "txSource", ",", "chain", ":", "chain", ",", "timeSource", ":", "timeSource", ",", "sigCache", ":", "sigCache", ",", "hashCache", ":", "hashCache", ",", "}", "\n", "}" ]

[ "NewBlkTmplGenerator", "returns", "a", "new", "block", "template", "generator", "for", "the", "given", "policy", "using", "transactions", "from", "the", "provided", "transaction", "source", ".", "The", "additional", "state", "-", "related", "fields", "are", "required", "in", "order", "to", "ensure", "the", "templates", "are", "built", "on", "top", "of", "the", "current", "best", "chain", "and", "adhere", "to", "the", "consensus", "rules", "." ]

[ "func", "(", "g", "*", "BlkTmplGenerator", ")", "UpdateBlockTime", "(", "msgBlock", "*", "wire", ".", "MsgBlock", ")", "error", "{", "// The new timestamp is potentially adjusted to ensure it comes after", "// the median time of the last several blocks per the chain consensus", "// rules.", "newTime", ":=", "medianAdjustedTime", "(", "g", ".", "chain", ".", "BestSnapshot", "(", ")", ",", "g", ".", "timeSource", ")", "\n", "msgBlock", ".", "Header", ".", "Timestamp", "=", "newTime", "\n\n", "// Recalculate the difficulty if running on a network that requires it.", "if", "g", ".", "chainParams", ".", "ReduceMinDifficulty", "{", "difficulty", ",", "err", ":=", "g", ".", "chain", ".", "CalcNextRequiredDifficulty", "(", "newTime", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "msgBlock", ".", "Header", ".", "Bits", "=", "difficulty", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "UpdateBlockTime", "updates", "the", "timestamp", "in", "the", "header", "of", "the", "passed", "block", "to", "the", "current", "time", "while", "taking", "into", "account", "the", "median", "time", "of", "the", "last", "several", "blocks", "to", "ensure", "the", "new", "time", "is", "after", "that", "time", "per", "the", "chain", "consensus", "rules", ".", "Finally", "it", "will", "update", "the", "target", "difficulty", "if", "needed", "based", "on", "the", "new", "time", "for", "the", "test", "networks", "since", "their", "target", "difficulty", "can", "change", "based", "upon", "time", "." ]

[ "func", "(", "g", "*", "BlkTmplGenerator", ")", "UpdateExtraNonce", "(", "msgBlock", "*", "wire", ".", "MsgBlock", ",", "blockHeight", "int32", ",", "extraNonce", "uint64", ")", "error", "{", "coinbaseScript", ",", "err", ":=", "standardCoinbaseScript", "(", "blockHeight", ",", "extraNonce", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "len", "(", "coinbaseScript", ")", ">", "blockchain", ".", "MaxCoinbaseScriptLen", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "len", "(", "coinbaseScript", ")", ",", "blockchain", ".", "MinCoinbaseScriptLen", ",", "blockchain", ".", "MaxCoinbaseScriptLen", ")", "\n", "}", "\n", "msgBlock", ".", "Transactions", "[", "0", "]", ".", "TxIn", "[", "0", "]", ".", "SignatureScript", "=", "coinbaseScript", "\n\n", "// TODO(davec): A btcutil.Block should use saved in the state to avoid", "// recalculating all of the other transaction hashes.", "// block.Transactions[0].InvalidateCache()", "// Recalculate the merkle root with the updated extra nonce.", "block", ":=", "btcutil", ".", "NewBlock", "(", "msgBlock", ")", "\n", "merkles", ":=", "blockchain", ".", "BuildMerkleTreeStore", "(", "block", ".", "Transactions", "(", ")", ",", "false", ")", "\n", "msgBlock", ".", "Header", ".", "MerkleRoot", "=", "*", "merkles", "[", "len", "(", "merkles", ")", "-", "1", "]", "\n", "return", "nil", "\n", "}" ]

[ "UpdateExtraNonce", "updates", "the", "extra", "nonce", "in", "the", "coinbase", "script", "of", "the", "passed", "block", "by", "regenerating", "the", "coinbase", "script", "with", "the", "passed", "value", "and", "block", "height", ".", "It", "also", "recalculates", "and", "updates", "the", "new", "merkle", "root", "that", "results", "from", "changing", "the", "coinbase", "script", "." ]

[ "func", "(", "c", "*", "helpCacher", ")", "rpcMethodHelp", "(", "method", "string", ")", "(", "string", ",", "error", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n\n", "// Return the cached method help if it exists.", "if", "help", ",", "exists", ":=", "c", ".", "methodHelp", "[", "method", "]", ";", "exists", "{", "return", "help", ",", "nil", "\n", "}", "\n\n", "// Look up the result types for the method.", "resultTypes", ",", "ok", ":=", "rpcResultTypes", "[", "method", "]", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", "+", "method", ")", "\n", "}", "\n\n", "// Generate, cache, and return the help.", "help", ",", "err", ":=", "btcjson", ".", "GenerateHelp", "(", "method", ",", "helpDescsEnUS", ",", "resultTypes", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "c", ".", "methodHelp", "[", "method", "]", "=", "help", "\n", "return", "help", ",", "nil", "\n", "}" ]

[ "rpcMethodHelp", "returns", "an", "RPC", "help", "string", "for", "the", "provided", "method", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "(", "c", "*", "helpCacher", ")", "rpcUsage", "(", "includeWebsockets", "bool", ")", "(", "string", ",", "error", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n\n", "// Return the cached usage if it is available.", "if", "c", ".", "usage", "!=", "\"", "\"", "{", "return", "c", ".", "usage", ",", "nil", "\n", "}", "\n\n", "// Generate a list of one-line usage for every command.", "usageTexts", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "rpcHandlers", ")", ")", "\n", "for", "k", ":=", "range", "rpcHandlers", "{", "usage", ",", "err", ":=", "btcjson", ".", "MethodUsageText", "(", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "usageTexts", "=", "append", "(", "usageTexts", ",", "usage", ")", "\n", "}", "\n\n", "// Include websockets commands if requested.", "if", "includeWebsockets", "{", "for", "k", ":=", "range", "wsHandlers", "{", "usage", ",", "err", ":=", "btcjson", ".", "MethodUsageText", "(", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "usageTexts", "=", "append", "(", "usageTexts", ",", "usage", ")", "\n", "}", "\n", "}", "\n\n", "sort", ".", "Sort", "(", "sort", ".", "StringSlice", "(", "usageTexts", ")", ")", "\n", "c", ".", "usage", "=", "strings", ".", "Join", "(", "usageTexts", ",", "\"", "\\n", "\"", ")", "\n", "return", "c", ".", "usage", ",", "nil", "\n", "}" ]

[ "rpcUsage", "returns", "one", "-", "line", "usage", "for", "all", "support", "RPC", "commands", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "dbFetchIndexerTip", "(", "dbTx", "database", ".", "Tx", ",", "idxKey", "[", "]", "byte", ")", "(", "*", "chainhash", ".", "Hash", ",", "int32", ",", "error", ")", "{", "indexesBucket", ":=", "dbTx", ".", "Metadata", "(", ")", ".", "Bucket", "(", "indexTipsBucketName", ")", "\n", "serialized", ":=", "indexesBucket", ".", "Get", "(", "idxKey", ")", "\n", "if", "len", "(", "serialized", ")", "<", "chainhash", ".", "HashSize", "+", "4", "{", "return", "nil", ",", "0", ",", "database", ".", "Error", "{", "ErrorCode", ":", "database", ".", "ErrCorruption", ",", "Description", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "string", "(", "idxKey", ")", ")", ",", "}", "\n", "}", "\n\n", "var", "hash", "chainhash", ".", "Hash", "\n", "copy", "(", "hash", "[", ":", "]", ",", "serialized", "[", ":", "chainhash", ".", "HashSize", "]", ")", "\n", "height", ":=", "int32", "(", "byteOrder", ".", "Uint32", "(", "serialized", "[", "chainhash", ".", "HashSize", ":", "]", ")", ")", "\n", "return", "&", "hash", ",", "height", ",", "nil", "\n", "}" ]

[ "dbFetchIndexerTip", "uses", "an", "existing", "database", "transaction", "to", "retrieve", "the", "hash", "and", "height", "of", "the", "current", "tip", "for", "the", "provided", "index", "." ]

[ "func", "dbIndexConnectBlock", "(", "dbTx", "database", ".", "Tx", ",", "indexer", "Indexer", ",", "block", "*", "btcutil", ".", "Block", ",", "stxo", "[", "]", "blockchain", ".", "SpentTxOut", ")", "error", "{", "// Assert that the block being connected properly connects to the", "// current tip of the index.", "idxKey", ":=", "indexer", ".", "Key", "(", ")", "\n", "curTipHash", ",", "_", ",", "err", ":=", "dbFetchIndexerTip", "(", "dbTx", ",", "idxKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "curTipHash", ".", "IsEqual", "(", "&", "block", ".", "MsgBlock", "(", ")", ".", "Header", ".", "PrevBlock", ")", "{", "return", "AssertError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "indexer", ".", "Name", "(", ")", ",", "curTipHash", ",", "block", ".", "Hash", "(", ")", ")", ")", "\n", "}", "\n\n", "// Notify the indexer with the connected block so it can index it.", "if", "err", ":=", "indexer", ".", "ConnectBlock", "(", "dbTx", ",", "block", ",", "stxo", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Update the current index tip.", "return", "dbPutIndexerTip", "(", "dbTx", ",", "idxKey", ",", "block", ".", "Hash", "(", ")", ",", "block", ".", "Height", "(", ")", ")", "\n", "}" ]

[ "dbIndexConnectBlock", "adds", "all", "of", "the", "index", "entries", "associated", "with", "the", "given", "block", "using", "the", "provided", "indexer", "and", "updates", "the", "tip", "of", "the", "indexer", "accordingly", ".", "An", "error", "will", "be", "returned", "if", "the", "current", "tip", "for", "the", "indexer", "is", "not", "the", "previous", "block", "for", "the", "passed", "block", "." ]

[ "func", "indexDropKey", "(", "idxKey", "[", "]", "byte", ")", "[", "]", "byte", "{", "dropKey", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "idxKey", ")", "+", "1", ")", "\n", "dropKey", "[", "0", "]", "=", "'d'", "\n", "copy", "(", "dropKey", "[", "1", ":", "]", ",", "idxKey", ")", "\n", "return", "dropKey", "\n", "}" ]

[ "indexDropKey", "returns", "the", "key", "for", "an", "index", "which", "indicates", "it", "is", "in", "the", "process", "of", "being", "dropped", "." ]

[ "func", "(", "m", "*", "Manager", ")", "maybeFinishDrops", "(", "interrupt", "<-", "chan", "struct", "{", "}", ")", "error", "{", "indexNeedsDrop", ":=", "make", "(", "[", "]", "bool", ",", "len", "(", "m", ".", "enabledIndexes", ")", ")", "\n", "err", ":=", "m", ".", "db", ".", "View", "(", "func", "(", "dbTx", "database", ".", "Tx", ")", "error", "{", "// None of the indexes needs to be dropped if the index tips", "// bucket hasn't been created yet.", "indexesBucket", ":=", "dbTx", ".", "Metadata", "(", ")", ".", "Bucket", "(", "indexTipsBucketName", ")", "\n", "if", "indexesBucket", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// Mark the indexer as requiring a drop if one is already in", "// progress.", "for", "i", ",", "indexer", ":=", "range", "m", ".", "enabledIndexes", "{", "dropKey", ":=", "indexDropKey", "(", "indexer", ".", "Key", "(", ")", ")", "\n", "if", "indexesBucket", ".", "Get", "(", "dropKey", ")", "!=", "nil", "{", "indexNeedsDrop", "[", "i", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "interruptRequested", "(", "interrupt", ")", "{", "return", "errInterruptRequested", "\n", "}", "\n\n", "// Finish dropping any of the enabled indexes that are already in the", "// middle of being dropped.", "for", "i", ",", "indexer", ":=", "range", "m", ".", "enabledIndexes", "{", "if", "!", "indexNeedsDrop", "[", "i", "]", "{", "continue", "\n", "}", "\n\n", "log", ".", "Infof", "(", "\"", "\"", ",", "indexer", ".", "Name", "(", ")", ")", "\n", "err", ":=", "dropIndex", "(", "m", ".", "db", ",", "indexer", ".", "Key", "(", ")", ",", "indexer", ".", "Name", "(", ")", ",", "interrupt", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "maybeFinishDrops", "determines", "if", "each", "of", "the", "enabled", "indexes", "are", "in", "the", "middle", "of", "being", "dropped", "and", "finishes", "dropping", "them", "when", "the", "are", ".", "This", "is", "necessary", "because", "dropping", "and", "index", "has", "to", "be", "done", "in", "several", "atomic", "steps", "rather", "than", "one", "big", "atomic", "step", "due", "to", "the", "massive", "number", "of", "entries", "." ]

[ "func", "(", "m", "*", "Manager", ")", "maybeCreateIndexes", "(", "dbTx", "database", ".", "Tx", ")", "error", "{", "indexesBucket", ":=", "dbTx", ".", "Metadata", "(", ")", ".", "Bucket", "(", "indexTipsBucketName", ")", "\n", "for", "_", ",", "indexer", ":=", "range", "m", ".", "enabledIndexes", "{", "// Nothing to do if the index tip already exists.", "idxKey", ":=", "indexer", ".", "Key", "(", ")", "\n", "if", "indexesBucket", ".", "Get", "(", "idxKey", ")", "!=", "nil", "{", "continue", "\n", "}", "\n\n", "// The tip for the index does not exist, so create it and", "// invoke the create callback for the index so it can perform", "// any one-time initialization it requires.", "if", "err", ":=", "indexer", ".", "Create", "(", "dbTx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Set the tip for the index to values which represent an", "// uninitialized index.", "err", ":=", "dbPutIndexerTip", "(", "dbTx", ",", "idxKey", ",", "&", "chainhash", ".", "Hash", "{", "}", ",", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "maybeCreateIndexes", "determines", "if", "each", "of", "the", "enabled", "indexes", "have", "already", "been", "created", "and", "creates", "them", "if", "not", "." ]

[ "func", "indexNeedsInputs", "(", "index", "Indexer", ")", "bool", "{", "if", "idx", ",", "ok", ":=", "index", ".", "(", "NeedsInputser", ")", ";", "ok", "{", "return", "idx", ".", "NeedsInputs", "(", ")", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "indexNeedsInputs", "returns", "whether", "or", "not", "the", "index", "needs", "access", "to", "the", "txouts", "referenced", "by", "the", "transaction", "inputs", "being", "indexed", "." ]

[ "func", "dbFetchTx", "(", "dbTx", "database", ".", "Tx", ",", "hash", "*", "chainhash", ".", "Hash", ")", "(", "*", "wire", ".", "MsgTx", ",", "error", ")", "{", "// Look up the location of the transaction.", "blockRegion", ",", "err", ":=", "dbFetchTxIndexEntry", "(", "dbTx", ",", "hash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "blockRegion", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "hash", ")", "\n", "}", "\n\n", "// Load the raw transaction bytes from the database.", "txBytes", ",", "err", ":=", "dbTx", ".", "FetchBlockRegion", "(", "blockRegion", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Deserialize the transaction.", "var", "msgTx", "wire", ".", "MsgTx", "\n", "err", "=", "msgTx", ".", "Deserialize", "(", "bytes", ".", "NewReader", "(", "txBytes", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "msgTx", ",", "nil", "\n", "}" ]

[ "dbFetchTx", "looks", "up", "the", "passed", "transaction", "hash", "in", "the", "transaction", "index", "and", "loads", "it", "from", "the", "database", "." ]

[ "func", "(", "m", "*", "Manager", ")", "ConnectBlock", "(", "dbTx", "database", ".", "Tx", ",", "block", "*", "btcutil", ".", "Block", ",", "stxos", "[", "]", "blockchain", ".", "SpentTxOut", ")", "error", "{", "// Call each of the currently active optional indexes with the block", "// being connected so they can update accordingly.", "for", "_", ",", "index", ":=", "range", "m", ".", "enabledIndexes", "{", "err", ":=", "dbIndexConnectBlock", "(", "dbTx", ",", "index", ",", "block", ",", "stxos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ConnectBlock", "must", "be", "invoked", "when", "a", "block", "is", "extending", "the", "main", "chain", ".", "It", "keeps", "track", "of", "the", "state", "of", "each", "index", "it", "is", "managing", "performs", "some", "sanity", "checks", "and", "invokes", "each", "indexer", ".", "This", "is", "part", "of", "the", "blockchain", ".", "IndexManager", "interface", "." ]

[ "func", "(", "m", "*", "Manager", ")", "DisconnectBlock", "(", "dbTx", "database", ".", "Tx", ",", "block", "*", "btcutil", ".", "Block", ",", "stxo", "[", "]", "blockchain", ".", "SpentTxOut", ")", "error", "{", "// Call each of the currently active optional indexes with the block", "// being disconnected so they can update accordingly.", "for", "_", ",", "index", ":=", "range", "m", ".", "enabledIndexes", "{", "err", ":=", "dbIndexDisconnectBlock", "(", "dbTx", ",", "index", ",", "block", ",", "stxo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DisconnectBlock", "must", "be", "invoked", "when", "a", "block", "is", "being", "disconnected", "from", "the", "end", "of", "the", "main", "chain", ".", "It", "keeps", "track", "of", "the", "state", "of", "each", "index", "it", "is", "managing", "performs", "some", "sanity", "checks", "and", "invokes", "each", "indexer", "to", "remove", "the", "index", "entries", "associated", "with", "the", "block", ".", "This", "is", "part", "of", "the", "blockchain", ".", "IndexManager", "interface", "." ]

[ "func", "NewManager", "(", "db", "database", ".", "DB", ",", "enabledIndexes", "[", "]", "Indexer", ")", "*", "Manager", "{", "return", "&", "Manager", "{", "db", ":", "db", ",", "enabledIndexes", ":", "enabledIndexes", ",", "}", "\n", "}" ]

[ "NewManager", "returns", "a", "new", "index", "manager", "with", "the", "provided", "indexes", "enabled", ".", "The", "manager", "returned", "satisfies", "the", "blockchain", ".", "IndexManager", "interface", "and", "thus", "cleanly", "plugs", "into", "the", "normal", "blockchain", "processing", "path", "." ]

[ "func", "(", "c", "*", "Client", ")", "RawRequestAsync", "(", "method", "string", ",", "params", "[", "]", "json", ".", "RawMessage", ")", "FutureRawResult", "{", "// Method may not be empty.", "if", "method", "==", "\"", "\"", "{", "return", "newFutureError", "(", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// Marshal parameters as \"[]\" instead of \"null\" when no parameters", "// are passed.", "if", "params", "==", "nil", "{", "params", "=", "[", "]", "json", ".", "RawMessage", "{", "}", "\n", "}", "\n\n", "// Create a raw JSON-RPC request using the provided method and params", "// and marshal it. This is done rather than using the sendCmd function", "// since that relies on marshalling registered btcjson commands rather", "// than custom commands.", "id", ":=", "c", ".", "NextID", "(", ")", "\n", "rawRequest", ":=", "&", "btcjson", ".", "Request", "{", "Jsonrpc", ":", "\"", "\"", ",", "ID", ":", "id", ",", "Method", ":", "method", ",", "Params", ":", "params", ",", "}", "\n", "marshalledJSON", ",", "err", ":=", "json", ".", "Marshal", "(", "rawRequest", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newFutureError", "(", "err", ")", "\n", "}", "\n\n", "// Generate the request and send it along with a channel to respond on.", "responseChan", ":=", "make", "(", "chan", "*", "response", ",", "1", ")", "\n", "jReq", ":=", "&", "jsonRequest", "{", "id", ":", "id", ",", "method", ":", "method", ",", "cmd", ":", "nil", ",", "marshalledJSON", ":", "marshalledJSON", ",", "responseChan", ":", "responseChan", ",", "}", "\n", "c", ".", "sendRequest", "(", "jReq", ")", "\n\n", "return", "responseChan", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "RawRequest", "(", "method", "string", ",", "params", "[", "]", "json", ".", "RawMessage", ")", "(", "json", ".", "RawMessage", ",", "error", ")", "{", "return", "c", ".", "RawRequestAsync", "(", "method", ",", "params", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "RawRequest", "allows", "the", "caller", "to", "send", "a", "raw", "or", "custom", "request", "to", "the", "server", ".", "This", "method", "may", "be", "used", "to", "send", "and", "receive", "requests", "and", "responses", "for", "requests", "that", "are", "not", "handled", "by", "this", "client", "package", "or", "to", "proxy", "partially", "unmarshaled", "requests", "to", "another", "JSON", "-", "RPC", "server", "if", "a", "request", "cannot", "be", "handled", "directly", "." ]

[ "func", "isNullOutpoint", "(", "outpoint", "*", "wire", ".", "OutPoint", ")", "bool", "{", "if", "outpoint", ".", "Index", "==", "math", ".", "MaxUint32", "&&", "outpoint", ".", "Hash", "==", "zeroHash", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isNullOutpoint", "determines", "whether", "or", "not", "a", "previous", "transaction", "output", "point", "is", "set", "." ]

[ "func", "IsCoinBaseTx", "(", "msgTx", "*", "wire", ".", "MsgTx", ")", "bool", "{", "// A coin base must only have one transaction input.", "if", "len", "(", "msgTx", ".", "TxIn", ")", "!=", "1", "{", "return", "false", "\n", "}", "\n\n", "// The previous output of a coin base must have a max value index and", "// a zero hash.", "prevOut", ":=", "&", "msgTx", ".", "TxIn", "[", "0", "]", ".", "PreviousOutPoint", "\n", "if", "prevOut", ".", "Index", "!=", "math", ".", "MaxUint32", "||", "prevOut", ".", "Hash", "!=", "zeroHash", "{", "return", "false", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "IsCoinBaseTx", "determines", "whether", "or", "not", "a", "transaction", "is", "a", "coinbase", ".", "A", "coinbase", "is", "a", "special", "transaction", "created", "by", "miners", "that", "has", "no", "inputs", ".", "This", "is", "represented", "in", "the", "block", "chain", "by", "a", "transaction", "with", "a", "single", "input", "that", "has", "a", "previous", "output", "transaction", "index", "set", "to", "the", "maximum", "value", "along", "with", "a", "zero", "hash", ".", "This", "function", "only", "differs", "from", "IsCoinBase", "in", "that", "it", "works", "with", "a", "raw", "wire", "transaction", "as", "opposed", "to", "a", "higher", "level", "util", "transaction", "." ]

[ "func", "SequenceLockActive", "(", "sequenceLock", "*", "SequenceLock", ",", "blockHeight", "int32", ",", "medianTimePast", "time", ".", "Time", ")", "bool", "{", "// If either the seconds, or height relative-lock time has not yet", "// reached, then the transaction is not yet mature according to its", "// sequence locks.", "if", "sequenceLock", ".", "Seconds", ">=", "medianTimePast", ".", "Unix", "(", ")", "||", "sequenceLock", ".", "BlockHeight", ">=", "blockHeight", "{", "return", "false", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "SequenceLockActive", "determines", "if", "a", "transaction", "s", "sequence", "locks", "have", "been", "met", "meaning", "that", "all", "the", "inputs", "of", "a", "given", "transaction", "have", "reached", "a", "height", "or", "time", "sufficient", "for", "their", "relative", "lock", "-", "time", "maturity", "." ]

[ "func", "IsFinalizedTransaction", "(", "tx", "*", "btcutil", ".", "Tx", ",", "blockHeight", "int32", ",", "blockTime", "time", ".", "Time", ")", "bool", "{", "msgTx", ":=", "tx", ".", "MsgTx", "(", ")", "\n\n", "// Lock time of zero means the transaction is finalized.", "lockTime", ":=", "msgTx", ".", "LockTime", "\n", "if", "lockTime", "==", "0", "{", "return", "true", "\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.", "blockTimeOrHeight", ":=", "int64", "(", "0", ")", "\n", "if", "lockTime", "<", "txscript", ".", "LockTimeThreshold", "{", "blockTimeOrHeight", "=", "int64", "(", "blockHeight", ")", "\n", "}", "else", "{", "blockTimeOrHeight", "=", "blockTime", ".", "Unix", "(", ")", "\n", "}", "\n", "if", "int64", "(", "lockTime", ")", "<", "blockTimeOrHeight", "{", "return", "true", "\n", "}", "\n\n", "// At this point, the transaction's lock time hasn't occurred yet, but", "// the transaction might still be finalized if the sequence number", "// for all transaction inputs is maxed out.", "for", "_", ",", "txIn", ":=", "range", "msgTx", ".", "TxIn", "{", "if", "txIn", ".", "Sequence", "!=", "math", ".", "MaxUint32", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsFinalizedTransaction", "determines", "whether", "or", "not", "a", "transaction", "is", "finalized", "." ]

[ "func", "isBIP0030Node", "(", "node", "*", "blockNode", ")", "bool", "{", "if", "node", ".", "height", "==", "91842", "&&", "node", ".", "hash", ".", "IsEqual", "(", "block91842Hash", ")", "{", "return", "true", "\n", "}", "\n\n", "if", "node", ".", "height", "==", "91880", "&&", "node", ".", "hash", ".", "IsEqual", "(", "block91880Hash", ")", "{", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "isBIP0030Node", "returns", "whether", "or", "not", "the", "passed", "node", "represents", "one", "of", "the", "two", "blocks", "that", "violate", "the", "BIP0030", "rule", "which", "prevents", "transactions", "from", "overwriting", "old", "ones", "." ]

[ "func", "CheckTransactionSanity", "(", "tx", "*", "btcutil", ".", "Tx", ")", "error", "{", "// A transaction must have at least one input.", "msgTx", ":=", "tx", ".", "MsgTx", "(", ")", "\n", "if", "len", "(", "msgTx", ".", "TxIn", ")", "==", "0", "{", "return", "ruleError", "(", "ErrNoTxInputs", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// A transaction must have at least one output.", "if", "len", "(", "msgTx", ".", "TxOut", ")", "==", "0", "{", "return", "ruleError", "(", "ErrNoTxOutputs", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// A transaction must not exceed the maximum allowed block payload when", "// serialized.", "serializedTxSize", ":=", "tx", ".", "MsgTx", "(", ")", ".", "SerializeSizeStripped", "(", ")", "\n", "if", "serializedTxSize", ">", "MaxBlockBaseSize", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "serializedTxSize", ",", "MaxBlockBaseSize", ")", "\n", "return", "ruleError", "(", "ErrTxTooBig", ",", "str", ")", "\n", "}", "\n\n", "// Ensure the transaction amounts are in range. Each transaction", "// output must not be negative or more than the max allowed per", "// transaction. Also, the total of all outputs must abide by the same", "// restrictions. All amounts in a transaction are in a unit value known", "// as a satoshi. One bitcoin is a quantity of satoshi as defined by the", "// SatoshiPerBitcoin constant.", "var", "totalSatoshi", "int64", "\n", "for", "_", ",", "txOut", ":=", "range", "msgTx", ".", "TxOut", "{", "satoshi", ":=", "txOut", ".", "Value", "\n", "if", "satoshi", "<", "0", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "satoshi", ")", "\n", "return", "ruleError", "(", "ErrBadTxOutValue", ",", "str", ")", "\n", "}", "\n", "if", "satoshi", ">", "btcutil", ".", "MaxSatoshi", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "satoshi", ",", "btcutil", ".", "MaxSatoshi", ")", "\n", "return", "ruleError", "(", "ErrBadTxOutValue", ",", "str", ")", "\n", "}", "\n\n", "// Two's complement int64 overflow guarantees that any overflow", "// is detected and reported. This is impossible for Bitcoin, but", "// perhaps possible if an alt increases the total money supply.", "totalSatoshi", "+=", "satoshi", "\n", "if", "totalSatoshi", "<", "0", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "btcutil", ".", "MaxSatoshi", ")", "\n", "return", "ruleError", "(", "ErrBadTxOutValue", ",", "str", ")", "\n", "}", "\n", "if", "totalSatoshi", ">", "btcutil", ".", "MaxSatoshi", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "totalSatoshi", ",", "btcutil", ".", "MaxSatoshi", ")", "\n", "return", "ruleError", "(", "ErrBadTxOutValue", ",", "str", ")", "\n", "}", "\n", "}", "\n\n", "// Check for duplicate transaction inputs.", "existingTxOut", ":=", "make", "(", "map", "[", "wire", ".", "OutPoint", "]", "struct", "{", "}", ")", "\n", "for", "_", ",", "txIn", ":=", "range", "msgTx", ".", "TxIn", "{", "if", "_", ",", "exists", ":=", "existingTxOut", "[", "txIn", ".", "PreviousOutPoint", "]", ";", "exists", "{", "return", "ruleError", "(", "ErrDuplicateTxInputs", ",", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n", "existingTxOut", "[", "txIn", ".", "PreviousOutPoint", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "// Coinbase script length must be between min and max length.", "if", "IsCoinBase", "(", "tx", ")", "{", "slen", ":=", "len", "(", "msgTx", ".", "TxIn", "[", "0", "]", ".", "SignatureScript", ")", "\n", "if", "slen", "<", "MinCoinbaseScriptLen", "||", "slen", ">", "MaxCoinbaseScriptLen", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "slen", ",", "MinCoinbaseScriptLen", ",", "MaxCoinbaseScriptLen", ")", "\n", "return", "ruleError", "(", "ErrBadCoinbaseScriptLen", ",", "str", ")", "\n", "}", "\n", "}", "else", "{", "// Previous transaction outputs referenced by the inputs to this", "// transaction must not be null.", "for", "_", ",", "txIn", ":=", "range", "msgTx", ".", "TxIn", "{", "if", "isNullOutpoint", "(", "&", "txIn", ".", "PreviousOutPoint", ")", "{", "return", "ruleError", "(", "ErrBadTxInput", ",", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CheckTransactionSanity", "performs", "some", "preliminary", "checks", "on", "a", "transaction", "to", "ensure", "it", "is", "sane", ".", "These", "checks", "are", "context", "free", "." ]

[ "func", "CountSigOps", "(", "tx", "*", "btcutil", ".", "Tx", ")", "int", "{", "msgTx", ":=", "tx", ".", "MsgTx", "(", ")", "\n\n", "// Accumulate the number of signature operations in all transaction", "// inputs.", "totalSigOps", ":=", "0", "\n", "for", "_", ",", "txIn", ":=", "range", "msgTx", ".", "TxIn", "{", "numSigOps", ":=", "txscript", ".", "GetSigOpCount", "(", "txIn", ".", "SignatureScript", ")", "\n", "totalSigOps", "+=", "numSigOps", "\n", "}", "\n\n", "// Accumulate the number of signature operations in all transaction", "// outputs.", "for", "_", ",", "txOut", ":=", "range", "msgTx", ".", "TxOut", "{", "numSigOps", ":=", "txscript", ".", "GetSigOpCount", "(", "txOut", ".", "PkScript", ")", "\n", "totalSigOps", "+=", "numSigOps", "\n", "}", "\n\n", "return", "totalSigOps", "\n", "}" ]

[ "CountSigOps", "returns", "the", "number", "of", "signature", "operations", "for", "all", "transaction", "input", "and", "output", "scripts", "in", "the", "provided", "transaction", ".", "This", "uses", "the", "quicker", "but", "imprecise", "signature", "operation", "counting", "mechanism", "from", "txscript", "." ]

[ "func", "CountP2SHSigOps", "(", "tx", "*", "btcutil", ".", "Tx", ",", "isCoinBaseTx", "bool", ",", "utxoView", "*", "UtxoViewpoint", ")", "(", "int", ",", "error", ")", "{", "// Coinbase transactions have no interesting inputs.", "if", "isCoinBaseTx", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "// Accumulate the number of signature operations in all transaction", "// inputs.", "msgTx", ":=", "tx", ".", "MsgTx", "(", ")", "\n", "totalSigOps", ":=", "0", "\n", "for", "txInIndex", ",", "txIn", ":=", "range", "msgTx", ".", "TxIn", "{", "// Ensure the referenced input transaction is available.", "utxo", ":=", "utxoView", ".", "LookupEntry", "(", "txIn", ".", "PreviousOutPoint", ")", "\n", "if", "utxo", "==", "nil", "||", "utxo", ".", "IsSpent", "(", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "txIn", ".", "PreviousOutPoint", ",", "tx", ".", "Hash", "(", ")", ",", "txInIndex", ")", "\n", "return", "0", ",", "ruleError", "(", "ErrMissingTxOut", ",", "str", ")", "\n", "}", "\n\n", "// We're only interested in pay-to-script-hash types, so skip", "// this input if it's not one.", "pkScript", ":=", "utxo", ".", "PkScript", "(", ")", "\n", "if", "!", "txscript", ".", "IsPayToScriptHash", "(", "pkScript", ")", "{", "continue", "\n", "}", "\n\n", "// Count the precise number of signature operations in the", "// referenced public key script.", "sigScript", ":=", "txIn", ".", "SignatureScript", "\n", "numSigOps", ":=", "txscript", ".", "GetPreciseSigOpCount", "(", "sigScript", ",", "pkScript", ",", "true", ")", "\n\n", "// We could potentially overflow the accumulator so check for", "// overflow.", "lastSigOps", ":=", "totalSigOps", "\n", "totalSigOps", "+=", "numSigOps", "\n", "if", "totalSigOps", "<", "lastSigOps", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "txIn", ".", "PreviousOutPoint", ")", "\n", "return", "0", ",", "ruleError", "(", "ErrTooManySigOps", ",", "str", ")", "\n", "}", "\n", "}", "\n\n", "return", "totalSigOps", ",", "nil", "\n", "}" ]

[ "CountP2SHSigOps", "returns", "the", "number", "of", "signature", "operations", "for", "all", "input", "transactions", "which", "are", "of", "the", "pay", "-", "to", "-", "script", "-", "hash", "type", ".", "This", "uses", "the", "precise", "signature", "operation", "counting", "mechanism", "from", "the", "script", "engine", "which", "requires", "access", "to", "the", "input", "transaction", "scripts", "." ]

[ "func", "checkBlockHeaderSanity", "(", "header", "*", "wire", ".", "BlockHeader", ",", "powLimit", "*", "big", ".", "Int", ",", "timeSource", "MedianTimeSource", ",", "flags", "BehaviorFlags", ")", "error", "{", "// Ensure the proof of work bits in the block header is in min/max range", "// and the block hash is less than the target value described by the", "// bits.", "err", ":=", "checkProofOfWork", "(", "header", ",", "powLimit", ",", "flags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// A block timestamp must not have a greater precision than one second.", "// This check is necessary because Go time.Time values support", "// nanosecond precision whereas the consensus rules only apply to", "// seconds and it's much nicer to deal with standard Go time values", "// instead of converting to seconds everywhere.", "if", "!", "header", ".", "Timestamp", ".", "Equal", "(", "time", ".", "Unix", "(", "header", ".", "Timestamp", ".", "Unix", "(", ")", ",", "0", ")", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "header", ".", "Timestamp", ")", "\n", "return", "ruleError", "(", "ErrInvalidTime", ",", "str", ")", "\n", "}", "\n\n", "// Ensure the block time is not too far in the future.", "maxTimestamp", ":=", "timeSource", ".", "AdjustedTime", "(", ")", ".", "Add", "(", "time", ".", "Second", "*", "MaxTimeOffsetSeconds", ")", "\n", "if", "header", ".", "Timestamp", ".", "After", "(", "maxTimestamp", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "header", ".", "Timestamp", ")", "\n", "return", "ruleError", "(", "ErrTimeTooNew", ",", "str", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkBlockHeaderSanity", "performs", "some", "preliminary", "checks", "on", "a", "block", "header", "to", "ensure", "it", "is", "sane", "before", "continuing", "with", "processing", ".", "These", "checks", "are", "context", "free", ".", "The", "flags", "do", "not", "modify", "the", "behavior", "of", "this", "function", "directly", "however", "they", "are", "needed", "to", "pass", "along", "to", "checkProofOfWork", "." ]

[ "func", "checkBlockSanity", "(", "block", "*", "btcutil", ".", "Block", ",", "powLimit", "*", "big", ".", "Int", ",", "timeSource", "MedianTimeSource", ",", "flags", "BehaviorFlags", ")", "error", "{", "msgBlock", ":=", "block", ".", "MsgBlock", "(", ")", "\n", "header", ":=", "&", "msgBlock", ".", "Header", "\n", "err", ":=", "checkBlockHeaderSanity", "(", "header", ",", "powLimit", ",", "timeSource", ",", "flags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// A block must have at least one transaction.", "numTx", ":=", "len", "(", "msgBlock", ".", "Transactions", ")", "\n", "if", "numTx", "==", "0", "{", "return", "ruleError", "(", "ErrNoTransactions", ",", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n\n", "// A block must not have more transactions than the max block payload or", "// else it is certainly over the weight limit.", "if", "numTx", ">", "MaxBlockBaseSize", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "numTx", ",", "MaxBlockBaseSize", ")", "\n", "return", "ruleError", "(", "ErrBlockTooBig", ",", "str", ")", "\n", "}", "\n\n", "// A block must not exceed the maximum allowed block payload when", "// serialized.", "serializedSize", ":=", "msgBlock", ".", "SerializeSizeStripped", "(", ")", "\n", "if", "serializedSize", ">", "MaxBlockBaseSize", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "serializedSize", ",", "MaxBlockBaseSize", ")", "\n", "return", "ruleError", "(", "ErrBlockTooBig", ",", "str", ")", "\n", "}", "\n\n", "// The first transaction in a block must be a coinbase.", "transactions", ":=", "block", ".", "Transactions", "(", ")", "\n", "if", "!", "IsCoinBase", "(", "transactions", "[", "0", "]", ")", "{", "return", "ruleError", "(", "ErrFirstTxNotCoinbase", ",", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n\n", "// A block must not have more than one coinbase.", "for", "i", ",", "tx", ":=", "range", "transactions", "[", "1", ":", "]", "{", "if", "IsCoinBase", "(", "tx", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "i", "+", "1", ")", "\n", "return", "ruleError", "(", "ErrMultipleCoinbases", ",", "str", ")", "\n", "}", "\n", "}", "\n\n", "// Do some preliminary checks on each transaction to ensure they are", "// sane before continuing.", "for", "_", ",", "tx", ":=", "range", "transactions", "{", "err", ":=", "CheckTransactionSanity", "(", "tx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Build merkle tree and ensure the calculated merkle root matches the", "// entry in the block header. This also has the effect of caching all", "// of the transaction hashes in the block to speed up future hash", "// checks. Bitcoind builds the tree here and checks the merkle root", "// after the following checks, but there is no reason not to check the", "// merkle root matches here.", "merkles", ":=", "BuildMerkleTreeStore", "(", "block", ".", "Transactions", "(", ")", ",", "false", ")", "\n", "calculatedMerkleRoot", ":=", "merkles", "[", "len", "(", "merkles", ")", "-", "1", "]", "\n", "if", "!", "header", ".", "MerkleRoot", ".", "IsEqual", "(", "calculatedMerkleRoot", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "header", ".", "MerkleRoot", ",", "calculatedMerkleRoot", ")", "\n", "return", "ruleError", "(", "ErrBadMerkleRoot", ",", "str", ")", "\n", "}", "\n\n", "// Check for duplicate transactions. This check will be fairly quick", "// since the transaction hashes are already cached due to building the", "// merkle tree above.", "existingTxHashes", ":=", "make", "(", "map", "[", "chainhash", ".", "Hash", "]", "struct", "{", "}", ")", "\n", "for", "_", ",", "tx", ":=", "range", "transactions", "{", "hash", ":=", "tx", ".", "Hash", "(", ")", "\n", "if", "_", ",", "exists", ":=", "existingTxHashes", "[", "*", "hash", "]", ";", "exists", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "hash", ")", "\n", "return", "ruleError", "(", "ErrDuplicateTx", ",", "str", ")", "\n", "}", "\n", "existingTxHashes", "[", "*", "hash", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "// The number of signature operations must be less than the maximum", "// allowed per block.", "totalSigOps", ":=", "0", "\n", "for", "_", ",", "tx", ":=", "range", "transactions", "{", "// We could potentially overflow the accumulator so check for", "// overflow.", "lastSigOps", ":=", "totalSigOps", "\n", "totalSigOps", "+=", "(", "CountSigOps", "(", "tx", ")", "*", "WitnessScaleFactor", ")", "\n", "if", "totalSigOps", "<", "lastSigOps", "||", "totalSigOps", ">", "MaxBlockSigOpsCost", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "totalSigOps", ",", "MaxBlockSigOpsCost", ")", "\n", "return", "ruleError", "(", "ErrTooManySigOps", ",", "str", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkBlockSanity", "performs", "some", "preliminary", "checks", "on", "a", "block", "to", "ensure", "it", "is", "sane", "before", "continuing", "with", "block", "processing", ".", "These", "checks", "are", "context", "free", ".", "The", "flags", "do", "not", "modify", "the", "behavior", "of", "this", "function", "directly", "however", "they", "are", "needed", "to", "pass", "along", "to", "checkBlockHeaderSanity", "." ]

[ "func", "CheckBlockSanity", "(", "block", "*", "btcutil", ".", "Block", ",", "powLimit", "*", "big", ".", "Int", ",", "timeSource", "MedianTimeSource", ")", "error", "{", "return", "checkBlockSanity", "(", "block", ",", "powLimit", ",", "timeSource", ",", "BFNone", ")", "\n", "}" ]

[ "CheckBlockSanity", "performs", "some", "preliminary", "checks", "on", "a", "block", "to", "ensure", "it", "is", "sane", "before", "continuing", "with", "block", "processing", ".", "These", "checks", "are", "context", "free", "." ]

[ "func", "ExtractCoinbaseHeight", "(", "coinbaseTx", "*", "btcutil", ".", "Tx", ")", "(", "int32", ",", "error", ")", "{", "sigScript", ":=", "coinbaseTx", ".", "MsgTx", "(", ")", ".", "TxIn", "[", "0", "]", ".", "SignatureScript", "\n", "if", "len", "(", "sigScript", ")", "<", "1", "{", "str", ":=", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", "\n", "str", "=", "fmt", ".", "Sprintf", "(", "str", ",", "serializedHeightVersion", ")", "\n", "return", "0", ",", "ruleError", "(", "ErrMissingCoinbaseHeight", ",", "str", ")", "\n", "}", "\n\n", "// Detect the case when the block height is a small integer encoded with", "// as single byte.", "opcode", ":=", "int", "(", "sigScript", "[", "0", "]", ")", "\n", "if", "opcode", "==", "txscript", ".", "OP_0", "{", "return", "0", ",", "nil", "\n", "}", "\n", "if", "opcode", ">=", "txscript", ".", "OP_1", "&&", "opcode", "<=", "txscript", ".", "OP_16", "{", "return", "int32", "(", "opcode", "-", "(", "txscript", ".", "OP_1", "-", "1", ")", ")", ",", "nil", "\n", "}", "\n\n", "// Otherwise, the opcode is the length of the following bytes which", "// encode in the block height.", "serializedLen", ":=", "int", "(", "sigScript", "[", "0", "]", ")", "\n", "if", "len", "(", "sigScript", "[", "1", ":", "]", ")", "<", "serializedLen", "{", "str", ":=", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", "\n", "str", "=", "fmt", ".", "Sprintf", "(", "str", ",", "serializedLen", ")", "\n", "return", "0", ",", "ruleError", "(", "ErrMissingCoinbaseHeight", ",", "str", ")", "\n", "}", "\n\n", "serializedHeightBytes", ":=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n", "copy", "(", "serializedHeightBytes", ",", "sigScript", "[", "1", ":", "serializedLen", "+", "1", "]", ")", "\n", "serializedHeight", ":=", "binary", ".", "LittleEndian", ".", "Uint64", "(", "serializedHeightBytes", ")", "\n\n", "return", "int32", "(", "serializedHeight", ")", ",", "nil", "\n", "}" ]

[ "ExtractCoinbaseHeight", "attempts", "to", "extract", "the", "height", "of", "the", "block", "from", "the", "scriptSig", "of", "a", "coinbase", "transaction", ".", "Coinbase", "heights", "are", "only", "present", "in", "blocks", "of", "version", "2", "or", "later", ".", "This", "was", "added", "as", "part", "of", "BIP0034", "." ]

[ "func", "checkSerializedHeight", "(", "coinbaseTx", "*", "btcutil", ".", "Tx", ",", "wantHeight", "int32", ")", "error", "{", "serializedHeight", ",", "err", ":=", "ExtractCoinbaseHeight", "(", "coinbaseTx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "serializedHeight", "!=", "wantHeight", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "serializedHeight", ",", "wantHeight", ")", "\n", "return", "ruleError", "(", "ErrBadCoinbaseHeight", ",", "str", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "checkSerializedHeight", "checks", "if", "the", "signature", "script", "in", "the", "passed", "transaction", "starts", "with", "the", "serialized", "block", "height", "of", "wantHeight", "." ]

[ "func", "(", "b", "*", "BlockChain", ")", "CheckConnectBlockTemplate", "(", "block", "*", "btcutil", ".", "Block", ")", "error", "{", "b", ".", "chainLock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "chainLock", ".", "Unlock", "(", ")", "\n\n", "// Skip the proof of work check as this is just a block template.", "flags", ":=", "BFNoPoWCheck", "\n\n", "// This only checks whether the block can be connected to the tip of the", "// current chain.", "tip", ":=", "b", ".", "bestChain", ".", "Tip", "(", ")", "\n", "header", ":=", "block", ".", "MsgBlock", "(", ")", ".", "Header", "\n", "if", "tip", ".", "hash", "!=", "header", ".", "PrevBlock", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "tip", ".", "hash", ",", "header", ".", "PrevBlock", ")", "\n", "return", "ruleError", "(", "ErrPrevBlockNotBest", ",", "str", ")", "\n", "}", "\n\n", "err", ":=", "checkBlockSanity", "(", "block", ",", "b", ".", "chainParams", ".", "PowLimit", ",", "b", ".", "timeSource", ",", "flags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "b", ".", "checkBlockContext", "(", "block", ",", "tip", ",", "flags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Leave the spent txouts entry nil in the state since the information", "// is not needed and thus extra work can be avoided.", "view", ":=", "NewUtxoViewpoint", "(", ")", "\n", "view", ".", "SetBestHash", "(", "&", "tip", ".", "hash", ")", "\n", "newNode", ":=", "newBlockNode", "(", "&", "header", ",", "tip", ")", "\n", "return", "b", ".", "checkConnectBlock", "(", "newNode", ",", "block", ",", "view", ",", "nil", ")", "\n", "}" ]

[ "CheckConnectBlockTemplate", "fully", "validates", "that", "connecting", "the", "passed", "block", "to", "the", "main", "chain", "does", "not", "violate", "any", "consensus", "rules", "aside", "from", "the", "proof", "of", "work", "requirement", ".", "The", "block", "must", "connect", "to", "the", "current", "tip", "of", "the", "main", "chain", ".", "This", "function", "is", "safe", "for", "concurrent", "access", "." ]

[ "func", "scriptError", "(", "c", "ErrorCode", ",", "desc", "string", ")", "Error", "{", "return", "Error", "{", "ErrorCode", ":", "c", ",", "Description", ":", "desc", "}", "\n", "}" ]

[ "scriptError", "creates", "an", "Error", "given", "a", "set", "of", "arguments", "." ]

[ "func", "IsErrorCode", "(", "err", "error", ",", "c", "ErrorCode", ")", "bool", "{", "serr", ",", "ok", ":=", "err", ".", "(", "Error", ")", "\n", "return", "ok", "&&", "serr", ".", "ErrorCode", "==", "c", "\n", "}" ]

[ "IsErrorCode", "returns", "whether", "or", "not", "the", "provided", "error", "is", "a", "script", "error", "with", "the", "provided", "error", "code", "." ]

[ "func", "(", "t", "ScriptClass", ")", "String", "(", ")", "string", "{", "if", "int", "(", "t", ")", ">", "len", "(", "scriptClassToName", ")", "||", "int", "(", "t", ")", "<", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "scriptClassToName", "[", "t", "]", "\n", "}" ]

[ "String", "implements", "the", "Stringer", "interface", "by", "returning", "the", "name", "of", "the", "enum", "script", "class", ".", "If", "the", "enum", "is", "invalid", "then", "Invalid", "will", "be", "returned", "." ]

[ "func", "isPubkey", "(", "pops", "[", "]", "parsedOpcode", ")", "bool", "{", "// Valid pubkeys are either 33 or 65 bytes.", "return", "len", "(", "pops", ")", "==", "2", "&&", "(", "len", "(", "pops", "[", "0", "]", ".", "data", ")", "==", "33", "||", "len", "(", "pops", "[", "0", "]", ".", "data", ")", "==", "65", ")", "&&", "pops", "[", "1", "]", ".", "opcode", ".", "value", "==", "OP_CHECKSIG", "\n", "}" ]

[ "isPubkey", "returns", "true", "if", "the", "script", "passed", "is", "a", "pay", "-", "to", "-", "pubkey", "transaction", "false", "otherwise", "." ]

[ "func", "isPubkeyHash", "(", "pops", "[", "]", "parsedOpcode", ")", "bool", "{", "return", "len", "(", "pops", ")", "==", "5", "&&", "pops", "[", "0", "]", ".", "opcode", ".", "value", "==", "OP_DUP", "&&", "pops", "[", "1", "]", ".", "opcode", ".", "value", "==", "OP_HASH160", "&&", "pops", "[", "2", "]", ".", "opcode", ".", "value", "==", "OP_DATA_20", "&&", "pops", "[", "3", "]", ".", "opcode", ".", "value", "==", "OP_EQUALVERIFY", "&&", "pops", "[", "4", "]", ".", "opcode", ".", "value", "==", "OP_CHECKSIG", "\n\n", "}" ]

[ "isPubkeyHash", "returns", "true", "if", "the", "script", "passed", "is", "a", "pay", "-", "to", "-", "pubkey", "-", "hash", "transaction", "false", "otherwise", "." ]

[ "func", "isMultiSig", "(", "pops", "[", "]", "parsedOpcode", ")", "bool", "{", "// The absolute minimum is 1 pubkey:", "// OP_0/OP_1-16 <pubkey> OP_1 OP_CHECKMULTISIG", "l", ":=", "len", "(", "pops", ")", "\n", "if", "l", "<", "4", "{", "return", "false", "\n", "}", "\n", "if", "!", "isSmallInt", "(", "pops", "[", "0", "]", ".", "opcode", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "isSmallInt", "(", "pops", "[", "l", "-", "2", "]", ".", "opcode", ")", "{", "return", "false", "\n", "}", "\n", "if", "pops", "[", "l", "-", "1", "]", ".", "opcode", ".", "value", "!=", "OP_CHECKMULTISIG", "{", "return", "false", "\n", "}", "\n\n", "// Verify the number of pubkeys specified matches the actual number", "// of pubkeys provided.", "if", "l", "-", "2", "-", "1", "!=", "asSmallInt", "(", "pops", "[", "l", "-", "2", "]", ".", "opcode", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "_", ",", "pop", ":=", "range", "pops", "[", "1", ":", "l", "-", "2", "]", "{", "// Valid pubkeys are either 33 or 65 bytes.", "if", "len", "(", "pop", ".", "data", ")", "!=", "33", "&&", "len", "(", "pop", ".", "data", ")", "!=", "65", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "isMultiSig", "returns", "true", "if", "the", "passed", "script", "is", "a", "multisig", "transaction", "false", "otherwise", "." ]

[ "func", "isNullData", "(", "pops", "[", "]", "parsedOpcode", ")", "bool", "{", "// A nulldata transaction is either a single OP_RETURN or an", "// OP_RETURN SMALLDATA (where SMALLDATA is a data push up to", "// MaxDataCarrierSize bytes).", "l", ":=", "len", "(", "pops", ")", "\n", "if", "l", "==", "1", "&&", "pops", "[", "0", "]", ".", "opcode", ".", "value", "==", "OP_RETURN", "{", "return", "true", "\n", "}", "\n\n", "return", "l", "==", "2", "&&", "pops", "[", "0", "]", ".", "opcode", ".", "value", "==", "OP_RETURN", "&&", "(", "isSmallInt", "(", "pops", "[", "1", "]", ".", "opcode", ")", "||", "pops", "[", "1", "]", ".", "opcode", ".", "value", "<=", "OP_PUSHDATA4", ")", "&&", "len", "(", "pops", "[", "1", "]", ".", "data", ")", "<=", "MaxDataCarrierSize", "\n", "}" ]

[ "isNullData", "returns", "true", "if", "the", "passed", "script", "is", "a", "null", "data", "transaction", "false", "otherwise", "." ]

[ "func", "typeOfScript", "(", "pops", "[", "]", "parsedOpcode", ")", "ScriptClass", "{", "if", "isPubkey", "(", "pops", ")", "{", "return", "PubKeyTy", "\n", "}", "else", "if", "isPubkeyHash", "(", "pops", ")", "{", "return", "PubKeyHashTy", "\n", "}", "else", "if", "isWitnessPubKeyHash", "(", "pops", ")", "{", "return", "WitnessV0PubKeyHashTy", "\n", "}", "else", "if", "isScriptHash", "(", "pops", ")", "{", "return", "ScriptHashTy", "\n", "}", "else", "if", "isWitnessScriptHash", "(", "pops", ")", "{", "return", "WitnessV0ScriptHashTy", "\n", "}", "else", "if", "isMultiSig", "(", "pops", ")", "{", "return", "MultiSigTy", "\n", "}", "else", "if", "isNullData", "(", "pops", ")", "{", "return", "NullDataTy", "\n", "}", "\n", "return", "NonStandardTy", "\n", "}" ]

[ "scriptType", "returns", "the", "type", "of", "the", "script", "being", "inspected", "from", "the", "known", "standard", "types", "." ]

[ "func", "GetScriptClass", "(", "script", "[", "]", "byte", ")", "ScriptClass", "{", "pops", ",", "err", ":=", "parseScript", "(", "script", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NonStandardTy", "\n", "}", "\n", "return", "typeOfScript", "(", "pops", ")", "\n", "}" ]

[ "GetScriptClass", "returns", "the", "class", "of", "the", "script", "passed", ".", "NonStandardTy", "will", "be", "returned", "when", "the", "script", "does", "not", "parse", "." ]

[ "func", "CalcScriptInfo", "(", "sigScript", ",", "pkScript", "[", "]", "byte", ",", "witness", "wire", ".", "TxWitness", ",", "bip16", ",", "segwit", "bool", ")", "(", "*", "ScriptInfo", ",", "error", ")", "{", "sigPops", ",", "err", ":=", "parseScript", "(", "sigScript", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "pkPops", ",", "err", ":=", "parseScript", "(", "pkScript", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Push only sigScript makes little sense.", "si", ":=", "new", "(", "ScriptInfo", ")", "\n", "si", ".", "PkScriptClass", "=", "typeOfScript", "(", "pkPops", ")", "\n\n", "// Can't have a signature script that doesn't just push data.", "if", "!", "isPushOnly", "(", "sigPops", ")", "{", "return", "nil", ",", "scriptError", "(", "ErrNotPushOnly", ",", "\"", "\"", ")", "\n", "}", "\n\n", "si", ".", "ExpectedInputs", "=", "expectedInputs", "(", "pkPops", ",", "si", ".", "PkScriptClass", ")", "\n\n", "switch", "{", "// Count sigops taking into account pay-to-script-hash.", "case", "si", ".", "PkScriptClass", "==", "ScriptHashTy", "&&", "bip16", "&&", "!", "segwit", ":", "// The pay-to-hash-script is the final data push of the", "// signature script.", "script", ":=", "sigPops", "[", "len", "(", "sigPops", ")", "-", "1", "]", ".", "data", "\n", "shPops", ",", "err", ":=", "parseScript", "(", "script", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "shInputs", ":=", "expectedInputs", "(", "shPops", ",", "typeOfScript", "(", "shPops", ")", ")", "\n", "if", "shInputs", "==", "-", "1", "{", "si", ".", "ExpectedInputs", "=", "-", "1", "\n", "}", "else", "{", "si", ".", "ExpectedInputs", "+=", "shInputs", "\n", "}", "\n", "si", ".", "SigOps", "=", "getSigOpCount", "(", "shPops", ",", "true", ")", "\n\n", "// All entries pushed to stack (or are OP_RESERVED and exec", "// will fail).", "si", ".", "NumInputs", "=", "len", "(", "sigPops", ")", "\n\n", "// If segwit is active, and this is a regular p2wkh output, then we'll", "// treat the script as a p2pkh output in essence.", "case", "si", ".", "PkScriptClass", "==", "WitnessV0PubKeyHashTy", "&&", "segwit", ":", "si", ".", "SigOps", "=", "GetWitnessSigOpCount", "(", "sigScript", ",", "pkScript", ",", "witness", ")", "\n", "si", ".", "NumInputs", "=", "len", "(", "witness", ")", "\n\n", "// We'll attempt to detect the nested p2sh case so we can accurately", "// count the signature operations involved.", "case", "si", ".", "PkScriptClass", "==", "ScriptHashTy", "&&", "IsWitnessProgram", "(", "sigScript", "[", "1", ":", "]", ")", "&&", "bip16", "&&", "segwit", ":", "// Extract the pushed witness program from the sigScript so we", "// can determine the number of expected inputs.", "pkPops", ",", "_", ":=", "parseScript", "(", "sigScript", "[", "1", ":", "]", ")", "\n", "shInputs", ":=", "expectedInputs", "(", "pkPops", ",", "typeOfScript", "(", "pkPops", ")", ")", "\n", "if", "shInputs", "==", "-", "1", "{", "si", ".", "ExpectedInputs", "=", "-", "1", "\n", "}", "else", "{", "si", ".", "ExpectedInputs", "+=", "shInputs", "\n", "}", "\n\n", "si", ".", "SigOps", "=", "GetWitnessSigOpCount", "(", "sigScript", ",", "pkScript", ",", "witness", ")", "\n\n", "si", ".", "NumInputs", "=", "len", "(", "witness", ")", "\n", "si", ".", "NumInputs", "+=", "len", "(", "sigPops", ")", "\n\n", "// If segwit is active, and this is a p2wsh output, then we'll need to", "// examine the witness script to generate accurate script info.", "case", "si", ".", "PkScriptClass", "==", "WitnessV0ScriptHashTy", "&&", "segwit", ":", "// The witness script is the final element of the witness", "// stack.", "witnessScript", ":=", "witness", "[", "len", "(", "witness", ")", "-", "1", "]", "\n", "pops", ",", "_", ":=", "parseScript", "(", "witnessScript", ")", "\n\n", "shInputs", ":=", "expectedInputs", "(", "pops", ",", "typeOfScript", "(", "pops", ")", ")", "\n", "if", "shInputs", "==", "-", "1", "{", "si", ".", "ExpectedInputs", "=", "-", "1", "\n", "}", "else", "{", "si", ".", "ExpectedInputs", "+=", "shInputs", "\n", "}", "\n\n", "si", ".", "SigOps", "=", "GetWitnessSigOpCount", "(", "sigScript", ",", "pkScript", ",", "witness", ")", "\n", "si", ".", "NumInputs", "=", "len", "(", "witness", ")", "\n\n", "default", ":", "si", ".", "SigOps", "=", "getSigOpCount", "(", "pkPops", ",", "true", ")", "\n\n", "// All entries pushed to stack (or are OP_RESERVED and exec", "// will fail).", "si", ".", "NumInputs", "=", "len", "(", "sigPops", ")", "\n", "}", "\n\n", "return", "si", ",", "nil", "\n", "}" ]

[ "CalcScriptInfo", "returns", "a", "structure", "providing", "data", "about", "the", "provided", "script", "pair", ".", "It", "will", "error", "if", "the", "pair", "is", "in", "someway", "invalid", "such", "that", "they", "can", "not", "be", "analysed", "i", ".", "e", ".", "if", "they", "do", "not", "parse", "or", "the", "pkScript", "is", "not", "a", "push", "-", "only", "script" ]

[ "func", "CalcMultiSigStats", "(", "script", "[", "]", "byte", ")", "(", "int", ",", "int", ",", "error", ")", "{", "pops", ",", "err", ":=", "parseScript", "(", "script", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "// A multi-signature script is of the pattern:", "// NUM_SIGS PUBKEY PUBKEY PUBKEY... NUM_PUBKEYS OP_CHECKMULTISIG", "// Therefore the number of signatures is the oldest item on the stack", "// and the number of pubkeys is the 2nd to last. Also, the absolute", "// minimum for a multi-signature script is 1 pubkey, so at least 4", "// items must be on the stack per:", "// OP_1 PUBKEY OP_1 OP_CHECKMULTISIG", "if", "len", "(", "pops", ")", "<", "4", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "script", ")", "\n", "return", "0", ",", "0", ",", "scriptError", "(", "ErrNotMultisigScript", ",", "str", ")", "\n", "}", "\n\n", "numSigs", ":=", "asSmallInt", "(", "pops", "[", "0", "]", ".", "opcode", ")", "\n", "numPubKeys", ":=", "asSmallInt", "(", "pops", "[", "len", "(", "pops", ")", "-", "2", "]", ".", "opcode", ")", "\n", "return", "numPubKeys", ",", "numSigs", ",", "nil", "\n", "}" ]

[ "CalcMultiSigStats", "returns", "the", "number", "of", "public", "keys", "and", "signatures", "from", "a", "multi", "-", "signature", "transaction", "script", ".", "The", "passed", "script", "MUST", "already", "be", "known", "to", "be", "a", "multi", "-", "signature", "script", "." ]

[ "func", "payToPubKeyHashScript", "(", "pubKeyHash", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "NewScriptBuilder", "(", ")", ".", "AddOp", "(", "OP_DUP", ")", ".", "AddOp", "(", "OP_HASH160", ")", ".", "AddData", "(", "pubKeyHash", ")", ".", "AddOp", "(", "OP_EQUALVERIFY", ")", ".", "AddOp", "(", "OP_CHECKSIG", ")", ".", "Script", "(", ")", "\n", "}" ]

[ "payToPubKeyHashScript", "creates", "a", "new", "script", "to", "pay", "a", "transaction", "output", "to", "a", "20", "-", "byte", "pubkey", "hash", ".", "It", "is", "expected", "that", "the", "input", "is", "a", "valid", "hash", "." ]

[ "func", "payToWitnessPubKeyHashScript", "(", "pubKeyHash", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "NewScriptBuilder", "(", ")", ".", "AddOp", "(", "OP_0", ")", ".", "AddData", "(", "pubKeyHash", ")", ".", "Script", "(", ")", "\n", "}" ]

[ "payToWitnessPubKeyHashScript", "creates", "a", "new", "script", "to", "pay", "to", "a", "version", "0", "pubkey", "hash", "witness", "program", ".", "The", "passed", "hash", "is", "expected", "to", "be", "valid", "." ]

[ "func", "payToScriptHashScript", "(", "scriptHash", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "NewScriptBuilder", "(", ")", ".", "AddOp", "(", "OP_HASH160", ")", ".", "AddData", "(", "scriptHash", ")", ".", "AddOp", "(", "OP_EQUAL", ")", ".", "Script", "(", ")", "\n", "}" ]

[ "payToScriptHashScript", "creates", "a", "new", "script", "to", "pay", "a", "transaction", "output", "to", "a", "script", "hash", ".", "It", "is", "expected", "that", "the", "input", "is", "a", "valid", "hash", "." ]

[ "func", "payToWitnessScriptHashScript", "(", "scriptHash", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "NewScriptBuilder", "(", ")", ".", "AddOp", "(", "OP_0", ")", ".", "AddData", "(", "scriptHash", ")", ".", "Script", "(", ")", "\n", "}" ]

[ "payToWitnessPubKeyHashScript", "creates", "a", "new", "script", "to", "pay", "to", "a", "version", "0", "script", "hash", "witness", "program", ".", "The", "passed", "hash", "is", "expected", "to", "be", "valid", "." ]

[ "func", "payToPubKeyScript", "(", "serializedPubKey", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "NewScriptBuilder", "(", ")", ".", "AddData", "(", "serializedPubKey", ")", ".", "AddOp", "(", "OP_CHECKSIG", ")", ".", "Script", "(", ")", "\n", "}" ]

[ "payToPubkeyScript", "creates", "a", "new", "script", "to", "pay", "a", "transaction", "output", "to", "a", "public", "key", ".", "It", "is", "expected", "that", "the", "input", "is", "a", "valid", "pubkey", "." ]

[ "func", "PayToAddrScript", "(", "addr", "btcutil", ".", "Address", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "const", "nilAddrErrStr", "=", "\"", "\"", "\n\n", "switch", "addr", ":=", "addr", ".", "(", "type", ")", "{", "case", "*", "btcutil", ".", "AddressPubKeyHash", ":", "if", "addr", "==", "nil", "{", "return", "nil", ",", "scriptError", "(", "ErrUnsupportedAddress", ",", "nilAddrErrStr", ")", "\n", "}", "\n", "return", "payToPubKeyHashScript", "(", "addr", ".", "ScriptAddress", "(", ")", ")", "\n\n", "case", "*", "btcutil", ".", "AddressScriptHash", ":", "if", "addr", "==", "nil", "{", "return", "nil", ",", "scriptError", "(", "ErrUnsupportedAddress", ",", "nilAddrErrStr", ")", "\n", "}", "\n", "return", "payToScriptHashScript", "(", "addr", ".", "ScriptAddress", "(", ")", ")", "\n\n", "case", "*", "btcutil", ".", "AddressPubKey", ":", "if", "addr", "==", "nil", "{", "return", "nil", ",", "scriptError", "(", "ErrUnsupportedAddress", ",", "nilAddrErrStr", ")", "\n", "}", "\n", "return", "payToPubKeyScript", "(", "addr", ".", "ScriptAddress", "(", ")", ")", "\n\n", "case", "*", "btcutil", ".", "AddressWitnessPubKeyHash", ":", "if", "addr", "==", "nil", "{", "return", "nil", ",", "scriptError", "(", "ErrUnsupportedAddress", ",", "nilAddrErrStr", ")", "\n", "}", "\n", "return", "payToWitnessPubKeyHashScript", "(", "addr", ".", "ScriptAddress", "(", ")", ")", "\n", "case", "*", "btcutil", ".", "AddressWitnessScriptHash", ":", "if", "addr", "==", "nil", "{", "return", "nil", ",", "scriptError", "(", "ErrUnsupportedAddress", ",", "nilAddrErrStr", ")", "\n", "}", "\n", "return", "payToWitnessScriptHashScript", "(", "addr", ".", "ScriptAddress", "(", ")", ")", "\n", "}", "\n\n", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "addr", ")", "\n", "return", "nil", ",", "scriptError", "(", "ErrUnsupportedAddress", ",", "str", ")", "\n", "}" ]

[ "PayToAddrScript", "creates", "a", "new", "script", "to", "pay", "a", "transaction", "output", "to", "a", "the", "specified", "address", "." ]

[ "func", "NullDataScript", "(", "data", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "len", "(", "data", ")", ">", "MaxDataCarrierSize", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "len", "(", "data", ")", ",", "MaxDataCarrierSize", ")", "\n", "return", "nil", ",", "scriptError", "(", "ErrTooMuchNullData", ",", "str", ")", "\n", "}", "\n\n", "return", "NewScriptBuilder", "(", ")", ".", "AddOp", "(", "OP_RETURN", ")", ".", "AddData", "(", "data", ")", ".", "Script", "(", ")", "\n", "}" ]

[ "NullDataScript", "creates", "a", "provably", "-", "prunable", "script", "containing", "OP_RETURN", "followed", "by", "the", "passed", "data", ".", "An", "Error", "with", "the", "error", "code", "ErrTooMuchNullData", "will", "be", "returned", "if", "the", "length", "of", "the", "passed", "data", "exceeds", "MaxDataCarrierSize", "." ]

[ "func", "MultiSigScript", "(", "pubkeys", "[", "]", "*", "btcutil", ".", "AddressPubKey", ",", "nrequired", "int", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "len", "(", "pubkeys", ")", "<", "nrequired", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "nrequired", ",", "len", "(", "pubkeys", ")", ")", "\n", "return", "nil", ",", "scriptError", "(", "ErrTooManyRequiredSigs", ",", "str", ")", "\n", "}", "\n\n", "builder", ":=", "NewScriptBuilder", "(", ")", ".", "AddInt64", "(", "int64", "(", "nrequired", ")", ")", "\n", "for", "_", ",", "key", ":=", "range", "pubkeys", "{", "builder", ".", "AddData", "(", "key", ".", "ScriptAddress", "(", ")", ")", "\n", "}", "\n", "builder", ".", "AddInt64", "(", "int64", "(", "len", "(", "pubkeys", ")", ")", ")", "\n", "builder", ".", "AddOp", "(", "OP_CHECKMULTISIG", ")", "\n\n", "return", "builder", ".", "Script", "(", ")", "\n", "}" ]

[ "MultiSigScript", "returns", "a", "valid", "script", "for", "a", "multisignature", "redemption", "where", "nrequired", "of", "the", "keys", "in", "pubkeys", "are", "required", "to", "have", "signed", "the", "transaction", "for", "success", ".", "An", "Error", "with", "the", "error", "code", "ErrTooManyRequiredSigs", "will", "be", "returned", "if", "nrequired", "is", "larger", "than", "the", "number", "of", "keys", "provided", "." ]

[ "func", "PushedData", "(", "script", "[", "]", "byte", ")", "(", "[", "]", "[", "]", "byte", ",", "error", ")", "{", "pops", ",", "err", ":=", "parseScript", "(", "script", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "data", "[", "]", "[", "]", "byte", "\n", "for", "_", ",", "pop", ":=", "range", "pops", "{", "if", "pop", ".", "data", "!=", "nil", "{", "data", "=", "append", "(", "data", ",", "pop", ".", "data", ")", "\n", "}", "else", "if", "pop", ".", "opcode", ".", "value", "==", "OP_0", "{", "data", "=", "append", "(", "data", ",", "nil", ")", "\n", "}", "\n", "}", "\n", "return", "data", ",", "nil", "\n", "}" ]

[ "PushedData", "returns", "an", "array", "of", "byte", "slices", "containing", "any", "pushed", "data", "found", "in", "the", "passed", "script", ".", "This", "includes", "OP_0", "but", "not", "OP_1", "-", "OP_16", "." ]

[ "func", "ExtractPkScriptAddrs", "(", "pkScript", "[", "]", "byte", ",", "chainParams", "*", "chaincfg", ".", "Params", ")", "(", "ScriptClass", ",", "[", "]", "btcutil", ".", "Address", ",", "int", ",", "error", ")", "{", "var", "addrs", "[", "]", "btcutil", ".", "Address", "\n", "var", "requiredSigs", "int", "\n\n", "// No valid addresses or required signatures if the script doesn't", "// parse.", "pops", ",", "err", ":=", "parseScript", "(", "pkScript", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NonStandardTy", ",", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "scriptClass", ":=", "typeOfScript", "(", "pops", ")", "\n", "switch", "scriptClass", "{", "case", "PubKeyHashTy", ":", "// A pay-to-pubkey-hash script is of the form:", "// OP_DUP OP_HASH160 <hash> OP_EQUALVERIFY OP_CHECKSIG", "// Therefore the pubkey hash is the 3rd item on the stack.", "// Skip the pubkey hash if it's invalid for some reason.", "requiredSigs", "=", "1", "\n", "addr", ",", "err", ":=", "btcutil", ".", "NewAddressPubKeyHash", "(", "pops", "[", "2", "]", ".", "data", ",", "chainParams", ")", "\n", "if", "err", "==", "nil", "{", "addrs", "=", "append", "(", "addrs", ",", "addr", ")", "\n", "}", "\n\n", "case", "WitnessV0PubKeyHashTy", ":", "// A pay-to-witness-pubkey-hash script is of thw form:", "// OP_0 <20-byte hash>", "// Therefore, the pubkey hash is the second item on the stack.", "// Skip the pubkey hash if it's invalid for some reason.", "requiredSigs", "=", "1", "\n", "addr", ",", "err", ":=", "btcutil", ".", "NewAddressWitnessPubKeyHash", "(", "pops", "[", "1", "]", ".", "data", ",", "chainParams", ")", "\n", "if", "err", "==", "nil", "{", "addrs", "=", "append", "(", "addrs", ",", "addr", ")", "\n", "}", "\n\n", "case", "PubKeyTy", ":", "// A pay-to-pubkey script is of the form:", "// <pubkey> OP_CHECKSIG", "// Therefore the pubkey is the first item on the stack.", "// Skip the pubkey if it's invalid for some reason.", "requiredSigs", "=", "1", "\n", "addr", ",", "err", ":=", "btcutil", ".", "NewAddressPubKey", "(", "pops", "[", "0", "]", ".", "data", ",", "chainParams", ")", "\n", "if", "err", "==", "nil", "{", "addrs", "=", "append", "(", "addrs", ",", "addr", ")", "\n", "}", "\n\n", "case", "ScriptHashTy", ":", "// A pay-to-script-hash script is of the form:", "// OP_HASH160 <scripthash> OP_EQUAL", "// Therefore the script hash is the 2nd item on the stack.", "// Skip the script hash if it's invalid for some reason.", "requiredSigs", "=", "1", "\n", "addr", ",", "err", ":=", "btcutil", ".", "NewAddressScriptHashFromHash", "(", "pops", "[", "1", "]", ".", "data", ",", "chainParams", ")", "\n", "if", "err", "==", "nil", "{", "addrs", "=", "append", "(", "addrs", ",", "addr", ")", "\n", "}", "\n\n", "case", "WitnessV0ScriptHashTy", ":", "// A pay-to-witness-script-hash script is of the form:", "// OP_0 <32-byte hash>", "// Therefore, the script hash is the second item on the stack.", "// Skip the script hash if it's invalid for some reason.", "requiredSigs", "=", "1", "\n", "addr", ",", "err", ":=", "btcutil", ".", "NewAddressWitnessScriptHash", "(", "pops", "[", "1", "]", ".", "data", ",", "chainParams", ")", "\n", "if", "err", "==", "nil", "{", "addrs", "=", "append", "(", "addrs", ",", "addr", ")", "\n", "}", "\n\n", "case", "MultiSigTy", ":", "// A multi-signature script is of the form:", "// <numsigs> <pubkey> <pubkey> <pubkey>... <numpubkeys> OP_CHECKMULTISIG", "// Therefore the number of required signatures is the 1st item", "// on the stack and the number of public keys is the 2nd to last", "// item on the stack.", "requiredSigs", "=", "asSmallInt", "(", "pops", "[", "0", "]", ".", "opcode", ")", "\n", "numPubKeys", ":=", "asSmallInt", "(", "pops", "[", "len", "(", "pops", ")", "-", "2", "]", ".", "opcode", ")", "\n\n", "// Extract the public keys while skipping any that are invalid.", "addrs", "=", "make", "(", "[", "]", "btcutil", ".", "Address", ",", "0", ",", "numPubKeys", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "numPubKeys", ";", "i", "++", "{", "addr", ",", "err", ":=", "btcutil", ".", "NewAddressPubKey", "(", "pops", "[", "i", "+", "1", "]", ".", "data", ",", "chainParams", ")", "\n", "if", "err", "==", "nil", "{", "addrs", "=", "append", "(", "addrs", ",", "addr", ")", "\n", "}", "\n", "}", "\n\n", "case", "NullDataTy", ":", "// Null data transactions have no addresses or required", "// signatures.", "case", "NonStandardTy", ":", "// Don't attempt to extract addresses or required signatures for", "// nonstandard transactions.", "}", "\n\n", "return", "scriptClass", ",", "addrs", ",", "requiredSigs", ",", "nil", "\n", "}" ]

[ "ExtractPkScriptAddrs", "returns", "the", "type", "of", "script", "addresses", "and", "required", "signatures", "associated", "with", "the", "passed", "PkScript", ".", "Note", "that", "it", "only", "works", "for", "standard", "transaction", "script", "types", ".", "Any", "data", "such", "as", "public", "keys", "which", "are", "invalid", "are", "omitted", "from", "the", "results", "." ]

[ "func", "NewFilteredBlockConnectedNtfn", "(", "height", "int32", ",", "header", "string", ",", "subscribedTxs", "[", "]", "string", ")", "*", "FilteredBlockConnectedNtfn", "{", "return", "&", "FilteredBlockConnectedNtfn", "{", "Height", ":", "height", ",", "Header", ":", "header", ",", "SubscribedTxs", ":", "subscribedTxs", ",", "}", "\n", "}" ]

[ "NewFilteredBlockConnectedNtfn", "returns", "a", "new", "instance", "which", "can", "be", "used", "to", "issue", "a", "filteredblockconnected", "JSON", "-", "RPC", "notification", "." ]

[ "func", "NewFilteredBlockDisconnectedNtfn", "(", "height", "int32", ",", "header", "string", ")", "*", "FilteredBlockDisconnectedNtfn", "{", "return", "&", "FilteredBlockDisconnectedNtfn", "{", "Height", ":", "height", ",", "Header", ":", "header", ",", "}", "\n", "}" ]

[ "NewFilteredBlockDisconnectedNtfn", "returns", "a", "new", "instance", "which", "can", "be", "used", "to", "issue", "a", "filteredblockdisconnected", "JSON", "-", "RPC", "notification", "." ]

[ "func", "NewTxAcceptedNtfn", "(", "txHash", "string", ",", "amount", "float64", ")", "*", "TxAcceptedNtfn", "{", "return", "&", "TxAcceptedNtfn", "{", "TxID", ":", "txHash", ",", "Amount", ":", "amount", ",", "}", "\n", "}" ]

[ "NewTxAcceptedNtfn", "returns", "a", "new", "instance", "which", "can", "be", "used", "to", "issue", "a", "txaccepted", "JSON", "-", "RPC", "notification", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetRawTransactionAsync", "(", "txHash", "*", "chainhash", ".", "Hash", ")", "FutureGetRawTransactionResult", "{", "hash", ":=", "\"", "\"", "\n", "if", "txHash", "!=", "nil", "{", "hash", "=", "txHash", ".", "String", "(", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewGetRawTransactionCmd", "(", "hash", ",", "btcjson", ".", "Int", "(", "0", ")", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "GetRawTransaction", "(", "txHash", "*", "chainhash", ".", "Hash", ")", "(", "*", "btcutil", ".", "Tx", ",", "error", ")", "{", "return", "c", ".", "GetRawTransactionAsync", "(", "txHash", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetRawTransaction", "returns", "a", "transaction", "given", "its", "hash", ".", "See", "GetRawTransactionVerbose", "to", "obtain", "additional", "information", "about", "the", "transaction", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetRawTransactionVerboseAsync", "(", "txHash", "*", "chainhash", ".", "Hash", ")", "FutureGetRawTransactionVerboseResult", "{", "hash", ":=", "\"", "\"", "\n", "if", "txHash", "!=", "nil", "{", "hash", "=", "txHash", ".", "String", "(", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewGetRawTransactionCmd", "(", "hash", ",", "btcjson", ".", "Int", "(", "1", ")", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "GetRawTransactionVerbose", "(", "txHash", "*", "chainhash", ".", "Hash", ")", "(", "*", "btcjson", ".", "TxRawResult", ",", "error", ")", "{", "return", "c", ".", "GetRawTransactionVerboseAsync", "(", "txHash", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetRawTransactionVerbose", "returns", "information", "about", "a", "transaction", "given", "its", "hash", ".", "See", "GetRawTransaction", "to", "obtain", "only", "the", "transaction", "already", "deserialized", "." ]

[ "func", "(", "r", "FutureDecodeRawTransactionResult", ")", "Receive", "(", ")", "(", "*", "btcjson", ".", "TxRawResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as a decoderawtransaction result object.", "var", "rawTxResult", "btcjson", ".", "TxRawResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "rawTxResult", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "rawTxResult", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "information", "about", "a", "transaction", "given", "its", "serialized", "bytes", "." ]

[ "func", "(", "c", "*", "Client", ")", "DecodeRawTransactionAsync", "(", "serializedTx", "[", "]", "byte", ")", "FutureDecodeRawTransactionResult", "{", "txHex", ":=", "hex", ".", "EncodeToString", "(", "serializedTx", ")", "\n", "cmd", ":=", "btcjson", ".", "NewDecodeRawTransactionCmd", "(", "txHex", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "DecodeRawTransaction", "(", "serializedTx", "[", "]", "byte", ")", "(", "*", "btcjson", ".", "TxRawResult", ",", "error", ")", "{", "return", "c", ".", "DecodeRawTransactionAsync", "(", "serializedTx", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "DecodeRawTransaction", "returns", "information", "about", "a", "transaction", "given", "its", "serialized", "bytes", "." ]

[ "func", "(", "c", "*", "Client", ")", "CreateRawTransactionAsync", "(", "inputs", "[", "]", "btcjson", ".", "TransactionInput", ",", "amounts", "map", "[", "btcutil", ".", "Address", "]", "btcutil", ".", "Amount", ",", "lockTime", "*", "int64", ")", "FutureCreateRawTransactionResult", "{", "convertedAmts", ":=", "make", "(", "map", "[", "string", "]", "float64", ",", "len", "(", "amounts", ")", ")", "\n", "for", "addr", ",", "amount", ":=", "range", "amounts", "{", "convertedAmts", "[", "addr", ".", "String", "(", ")", "]", "=", "amount", ".", "ToBTC", "(", ")", "\n", "}", "\n", "cmd", ":=", "btcjson", ".", "NewCreateRawTransactionCmd", "(", "inputs", ",", "convertedAmts", ",", "lockTime", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "CreateRawTransaction", "(", "inputs", "[", "]", "btcjson", ".", "TransactionInput", ",", "amounts", "map", "[", "btcutil", ".", "Address", "]", "btcutil", ".", "Amount", ",", "lockTime", "*", "int64", ")", "(", "*", "wire", ".", "MsgTx", ",", "error", ")", "{", "return", "c", ".", "CreateRawTransactionAsync", "(", "inputs", ",", "amounts", ",", "lockTime", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "CreateRawTransaction", "returns", "a", "new", "transaction", "spending", "the", "provided", "inputs", "and", "sending", "to", "the", "provided", "addresses", "." ]

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

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "result", "of", "submitting", "the", "encoded", "transaction", "to", "the", "server", "which", "then", "relays", "it", "to", "the", "network", "." ]

[ "func", "(", "c", "*", "Client", ")", "SendRawTransactionAsync", "(", "tx", "*", "wire", ".", "MsgTx", ",", "allowHighFees", "bool", ")", "FutureSendRawTransactionResult", "{", "txHex", ":=", "\"", "\"", "\n", "if", "tx", "!=", "nil", "{", "// Serialize the transaction and convert to hex string.", "buf", ":=", "bytes", ".", "NewBuffer", "(", "make", "(", "[", "]", "byte", ",", "0", ",", "tx", ".", "SerializeSize", "(", ")", ")", ")", "\n", "if", "err", ":=", "tx", ".", "Serialize", "(", "buf", ")", ";", "err", "!=", "nil", "{", "return", "newFutureError", "(", "err", ")", "\n", "}", "\n", "txHex", "=", "hex", ".", "EncodeToString", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewSendRawTransactionCmd", "(", "txHex", ",", "&", "allowHighFees", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "SendRawTransaction", "(", "tx", "*", "wire", ".", "MsgTx", ",", "allowHighFees", "bool", ")", "(", "*", "chainhash", ".", "Hash", ",", "error", ")", "{", "return", "c", ".", "SendRawTransactionAsync", "(", "tx", ",", "allowHighFees", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "SendRawTransaction", "submits", "the", "encoded", "transaction", "to", "the", "server", "which", "will", "then", "relay", "it", "to", "the", "network", "." ]

[ "func", "(", "r", "FutureSignRawTransactionResult", ")", "Receive", "(", ")", "(", "*", "wire", ".", "MsgTx", ",", "bool", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "// Unmarshal as a signrawtransaction result.", "var", "signRawTxResult", "btcjson", ".", "SignRawTransactionResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "signRawTxResult", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "// Decode the serialized transaction hex to raw bytes.", "serializedTx", ",", "err", ":=", "hex", ".", "DecodeString", "(", "signRawTxResult", ".", "Hex", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "// Deserialize the transaction and return it.", "var", "msgTx", "wire", ".", "MsgTx", "\n", "if", "err", ":=", "msgTx", ".", "Deserialize", "(", "bytes", ".", "NewReader", "(", "serializedTx", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "return", "&", "msgTx", ",", "signRawTxResult", ".", "Complete", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "signed", "transaction", "as", "well", "as", "whether", "or", "not", "all", "inputs", "are", "now", "signed", "." ]

[ "func", "(", "c", "*", "Client", ")", "SignRawTransaction2", "(", "tx", "*", "wire", ".", "MsgTx", ",", "inputs", "[", "]", "btcjson", ".", "RawTxInput", ")", "(", "*", "wire", ".", "MsgTx", ",", "bool", ",", "error", ")", "{", "return", "c", ".", "SignRawTransaction2Async", "(", "tx", ",", "inputs", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "SignRawTransaction2", "signs", "inputs", "for", "the", "passed", "transaction", "given", "the", "list", "of", "information", "about", "the", "input", "transactions", "needed", "to", "perform", "the", "signing", "process", ".", "This", "only", "input", "transactions", "that", "need", "to", "be", "specified", "are", "ones", "the", "RPC", "server", "does", "not", "already", "know", ".", "Already", "known", "input", "transactions", "will", "be", "merged", "with", "the", "specified", "transactions", ".", "See", "SignRawTransaction", "if", "the", "RPC", "server", "already", "knows", "the", "input", "transactions", "." ]

[ "func", "(", "c", "*", "Client", ")", "SignRawTransaction3Async", "(", "tx", "*", "wire", ".", "MsgTx", ",", "inputs", "[", "]", "btcjson", ".", "RawTxInput", ",", "privKeysWIF", "[", "]", "string", ")", "FutureSignRawTransactionResult", "{", "txHex", ":=", "\"", "\"", "\n", "if", "tx", "!=", "nil", "{", "// Serialize the transaction and convert to hex string.", "buf", ":=", "bytes", ".", "NewBuffer", "(", "make", "(", "[", "]", "byte", ",", "0", ",", "tx", ".", "SerializeSize", "(", ")", ")", ")", "\n", "if", "err", ":=", "tx", ".", "Serialize", "(", "buf", ")", ";", "err", "!=", "nil", "{", "return", "newFutureError", "(", "err", ")", "\n", "}", "\n", "txHex", "=", "hex", ".", "EncodeToString", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewSignRawTransactionCmd", "(", "txHex", ",", "&", "inputs", ",", "&", "privKeysWIF", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "SearchRawTransactionsAsync", "(", "address", "btcutil", ".", "Address", ",", "skip", ",", "count", "int", ",", "reverse", "bool", ",", "filterAddrs", "[", "]", "string", ")", "FutureSearchRawTransactionsResult", "{", "addr", ":=", "address", ".", "EncodeAddress", "(", ")", "\n", "verbose", ":=", "btcjson", ".", "Int", "(", "0", ")", "\n", "cmd", ":=", "btcjson", ".", "NewSearchRawTransactionsCmd", "(", "addr", ",", "verbose", ",", "&", "skip", ",", "&", "count", ",", "nil", ",", "&", "reverse", ",", "&", "filterAddrs", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "SearchRawTransactionsVerboseAsync", "(", "address", "btcutil", ".", "Address", ",", "skip", ",", "count", "int", ",", "includePrevOut", ",", "reverse", "bool", ",", "filterAddrs", "*", "[", "]", "string", ")", "FutureSearchRawTransactionsVerboseResult", "{", "addr", ":=", "address", ".", "EncodeAddress", "(", ")", "\n", "verbose", ":=", "btcjson", ".", "Int", "(", "1", ")", "\n", "var", "prevOut", "*", "int", "\n", "if", "includePrevOut", "{", "prevOut", "=", "btcjson", ".", "Int", "(", "1", ")", "\n", "}", "\n", "cmd", ":=", "btcjson", ".", "NewSearchRawTransactionsCmd", "(", "addr", ",", "verbose", ",", "&", "skip", ",", "&", "count", ",", "prevOut", ",", "&", "reverse", ",", "filterAddrs", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "r", "FutureDecodeScriptResult", ")", "Receive", "(", ")", "(", "*", "btcjson", ".", "DecodeScriptResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as a decodescript result object.", "var", "decodeScriptResult", "btcjson", ".", "DecodeScriptResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "decodeScriptResult", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "decodeScriptResult", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "information", "about", "a", "script", "given", "its", "serialized", "bytes", "." ]

[ "func", "(", "c", "*", "Client", ")", "DecodeScriptAsync", "(", "serializedScript", "[", "]", "byte", ")", "FutureDecodeScriptResult", "{", "scriptHex", ":=", "hex", ".", "EncodeToString", "(", "serializedScript", ")", "\n", "cmd", ":=", "btcjson", ".", "NewDecodeScriptCmd", "(", "scriptHex", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

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

[ "func", "(", "c", "*", "Client", ")", "DecodeScript", "(", "serializedScript", "[", "]", "byte", ")", "(", "*", "btcjson", ".", "DecodeScriptResult", ",", "error", ")", "{", "return", "c", ".", "DecodeScriptAsync", "(", "serializedScript", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "DecodeScript", "returns", "information", "about", "a", "script", "given", "its", "serialized", "bytes", "." ]

[ "func", "newLdbCacheIter", "(", "snap", "*", "dbCacheSnapshot", ",", "slice", "*", "util", ".", "Range", ")", "*", "ldbCacheIter", "{", "iter", ":=", "snap", ".", "pendingKeys", ".", "Iterator", "(", "slice", ".", "Start", ",", "slice", ".", "Limit", ")", "\n", "return", "&", "ldbCacheIter", "{", "Iterator", ":", "iter", "}", "\n", "}" ]

[ "newLdbCacheIter", "creates", "a", "new", "treap", "iterator", "for", "the", "given", "slice", "against", "the", "pending", "keys", "for", "the", "passed", "cache", "snapshot", "and", "returns", "it", "wrapped", "in", "an", "ldbCacheIter", "so", "it", "can", "be", "used", "as", "a", "leveldb", "iterator", "." ]

[ "func", "(", "iter", "*", "dbCacheIterator", ")", "skipPendingUpdates", "(", "forwards", "bool", ")", "{", "for", "iter", ".", "dbIter", ".", "Valid", "(", ")", "{", "var", "skip", "bool", "\n", "key", ":=", "iter", ".", "dbIter", ".", "Key", "(", ")", "\n", "if", "iter", ".", "cacheSnapshot", ".", "pendingRemove", ".", "Has", "(", "key", ")", "{", "skip", "=", "true", "\n", "}", "else", "if", "iter", ".", "cacheSnapshot", ".", "pendingKeys", ".", "Has", "(", "key", ")", "{", "skip", "=", "true", "\n", "}", "\n", "if", "!", "skip", "{", "break", "\n", "}", "\n\n", "if", "forwards", "{", "iter", ".", "dbIter", ".", "Next", "(", ")", "\n", "}", "else", "{", "iter", ".", "dbIter", ".", "Prev", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "skipPendingUpdates", "skips", "any", "keys", "at", "the", "current", "database", "iterator", "position", "that", "are", "being", "updated", "by", "the", "cache", ".", "The", "forwards", "flag", "indicates", "the", "direction", "the", "iterator", "is", "moving", "." ]

[ "func", "(", "iter", "*", "dbCacheIterator", ")", "chooseIterator", "(", "forwards", "bool", ")", "bool", "{", "// Skip any keys at the current database iterator position that are", "// being updated by the cache.", "iter", ".", "skipPendingUpdates", "(", "forwards", ")", "\n\n", "// When both iterators are exhausted, the iterator is exhausted too.", "if", "!", "iter", ".", "dbIter", ".", "Valid", "(", ")", "&&", "!", "iter", ".", "cacheIter", ".", "Valid", "(", ")", "{", "iter", ".", "currentIter", "=", "nil", "\n", "return", "false", "\n", "}", "\n\n", "// Choose the database iterator when the cache iterator is exhausted.", "if", "!", "iter", ".", "cacheIter", ".", "Valid", "(", ")", "{", "iter", ".", "currentIter", "=", "iter", ".", "dbIter", "\n", "return", "true", "\n", "}", "\n\n", "// Choose the cache iterator when the database iterator is exhausted.", "if", "!", "iter", ".", "dbIter", ".", "Valid", "(", ")", "{", "iter", ".", "currentIter", "=", "iter", ".", "cacheIter", "\n", "return", "true", "\n", "}", "\n\n", "// Both iterators are valid, so choose the iterator with either the", "// smaller or larger key depending on the forwards flag.", "compare", ":=", "bytes", ".", "Compare", "(", "iter", ".", "dbIter", ".", "Key", "(", ")", ",", "iter", ".", "cacheIter", ".", "Key", "(", ")", ")", "\n", "if", "(", "forwards", "&&", "compare", ">", "0", ")", "||", "(", "!", "forwards", "&&", "compare", "<", "0", ")", "{", "iter", ".", "currentIter", "=", "iter", ".", "cacheIter", "\n", "}", "else", "{", "iter", ".", "currentIter", "=", "iter", ".", "dbIter", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "chooseIterator", "first", "skips", "any", "entries", "in", "the", "database", "iterator", "that", "are", "being", "updated", "by", "the", "cache", "and", "sets", "the", "current", "iterator", "to", "the", "appropriate", "iterator", "depending", "on", "their", "validity", "and", "the", "order", "they", "compare", "in", "while", "taking", "into", "account", "the", "direction", "flag", ".", "When", "the", "iterator", "is", "being", "moved", "forwards", "and", "both", "iterators", "are", "valid", "the", "iterator", "with", "the", "smaller", "key", "is", "chosen", "and", "vice", "versa", "when", "the", "iterator", "is", "being", "moved", "backwards", "." ]

[ "func", "(", "iter", "*", "dbCacheIterator", ")", "Key", "(", ")", "[", "]", "byte", "{", "// Nothing to return if iterator is exhausted.", "if", "iter", ".", "currentIter", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "iter", ".", "currentIter", ".", "Key", "(", ")", "\n", "}" ]

[ "Key", "returns", "the", "current", "key", "the", "iterator", "is", "pointing", "to", ".", "This", "is", "part", "of", "the", "leveldb", "iterator", ".", "Iterator", "interface", "implementation", "." ]

[ "func", "(", "iter", "*", "dbCacheIterator", ")", "Value", "(", ")", "[", "]", "byte", "{", "// Nothing to return if iterator is exhausted.", "if", "iter", ".", "currentIter", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "iter", ".", "currentIter", ".", "Value", "(", ")", "\n", "}" ]

[ "Value", "returns", "the", "current", "value", "the", "iterator", "is", "pointing", "to", ".", "This", "is", "part", "of", "the", "leveldb", "iterator", ".", "Iterator", "interface", "implementation", "." ]

[ "func", "(", "snap", "*", "dbCacheSnapshot", ")", "Release", "(", ")", "{", "snap", ".", "dbSnapshot", ".", "Release", "(", ")", "\n", "snap", ".", "pendingKeys", "=", "nil", "\n", "snap", ".", "pendingRemove", "=", "nil", "\n", "}" ]

[ "Release", "releases", "the", "snapshot", "." ]

[ "func", "(", "snap", "*", "dbCacheSnapshot", ")", "NewIterator", "(", "slice", "*", "util", ".", "Range", ")", "*", "dbCacheIterator", "{", "return", "&", "dbCacheIterator", "{", "dbIter", ":", "snap", ".", "dbSnapshot", ".", "NewIterator", "(", "slice", ",", "nil", ")", ",", "cacheIter", ":", "newLdbCacheIter", "(", "snap", ",", "slice", ")", ",", "cacheSnapshot", ":", "snap", ",", "}", "\n", "}" ]

[ "NewIterator", "returns", "a", "new", "iterator", "for", "the", "snapshot", ".", "The", "newly", "returned", "iterator", "is", "not", "pointing", "to", "a", "valid", "item", "until", "a", "call", "to", "one", "of", "the", "methods", "to", "position", "it", "is", "made", ".", "The", "slice", "parameter", "allows", "the", "iterator", "to", "be", "limited", "to", "a", "range", "of", "keys", ".", "The", "start", "key", "is", "inclusive", "and", "the", "limit", "key", "is", "exclusive", ".", "Either", "or", "both", "can", "be", "nil", "if", "the", "functionality", "is", "not", "desired", "." ]

[ "func", "(", "c", "*", "dbCache", ")", "Snapshot", "(", ")", "(", "*", "dbCacheSnapshot", ",", "error", ")", "{", "dbSnapshot", ",", "err", ":=", "c", ".", "ldb", ".", "GetSnapshot", "(", ")", "\n", "if", "err", "!=", "nil", "{", "str", ":=", "\"", "\"", "\n", "return", "nil", ",", "convertErr", "(", "str", ",", "err", ")", "\n", "}", "\n\n", "// Since the cached keys to be added and removed use an immutable treap,", "// a snapshot is simply obtaining the root of the tree under the lock", "// which is used to atomically swap the root.", "c", ".", "cacheLock", ".", "RLock", "(", ")", "\n", "cacheSnapshot", ":=", "&", "dbCacheSnapshot", "{", "dbSnapshot", ":", "dbSnapshot", ",", "pendingKeys", ":", "c", ".", "cachedKeys", ",", "pendingRemove", ":", "c", ".", "cachedRemove", ",", "}", "\n", "c", ".", "cacheLock", ".", "RUnlock", "(", ")", "\n", "return", "cacheSnapshot", ",", "nil", "\n", "}" ]

[ "Snapshot", "returns", "a", "snapshot", "of", "the", "database", "cache", "and", "underlying", "database", "at", "a", "particular", "point", "in", "time", ".", "The", "snapshot", "must", "be", "released", "after", "use", "by", "calling", "Release", "." ]

[ "func", "(", "c", "*", "dbCache", ")", "updateDB", "(", "fn", "func", "(", "ldbTx", "*", "leveldb", ".", "Transaction", ")", "error", ")", "error", "{", "// Start a leveldb transaction.", "ldbTx", ",", "err", ":=", "c", ".", "ldb", ".", "OpenTransaction", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "convertErr", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "fn", "(", "ldbTx", ")", ";", "err", "!=", "nil", "{", "ldbTx", ".", "Discard", "(", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Commit the leveldb transaction and convert any errors as needed.", "if", "err", ":=", "ldbTx", ".", "Commit", "(", ")", ";", "err", "!=", "nil", "{", "return", "convertErr", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "updateDB", "invokes", "the", "passed", "function", "in", "the", "context", "of", "a", "managed", "leveldb", "transaction", ".", "Any", "errors", "returned", "from", "the", "user", "-", "supplied", "function", "will", "cause", "the", "transaction", "to", "be", "rolled", "back", "and", "are", "returned", "from", "this", "function", ".", "Otherwise", "the", "transaction", "is", "committed", "when", "the", "user", "-", "supplied", "function", "returns", "a", "nil", "error", "." ]