Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "DeepFlatten", "(", "slice", "[", "]", "interface", "{", "}", ",", "depth", "int", ")", "[", "]", "interface", "{", "}", "{", "if", "depth", "==", "0", "{", "return", "slice", "\n", "}", "\n", "returnSlice", ":=", "[", "]", "interface", "{", "}", "{", "}", "\n\n", "for", "_", ",", "element", ":=", "range", "slice", "{", "if", "s", ",", "ok", ":=", "element", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "returnSlice", "=", "append", "(", "returnSlice", ",", "DeepFlatten", "(", "s", ",", "depth", "-", "1", ")", "...", ")", "\n", "}", "else", "{", "returnSlice", "=", "append", "(", "returnSlice", ",", "element", ")", "\n", "}", "\n\n", "}", "\n\n", "return", "returnSlice", "\n", "}" ]

[ "Recursively", "flattens", "a", "list", "by", "splicing", "any", "sub", "-", "lists", "into", "their", "parent", "until", "depth", "is", "reached", ".", "If", "a", "negative", "number", "is", "passed", "for", "depth", "then", "it", "continues", "until", "no", "elements", "of", "the", "returned", "list", "are", "lists" ]

[ "func", "(", "trans", "*", "Transactor", ")", "BroadcastTxAsync", "(", "ctx", "context", ".", "Context", ",", "txEnv", "*", "txs", ".", "Envelope", ")", "(", "*", "txs", ".", "Receipt", ",", "error", ")", "{", "return", "trans", ".", "CheckTxSync", "(", "ctx", ",", "txEnv", ")", "\n", "}" ]

[ "Broadcast", "a", "transaction", "without", "waiting", "for", "confirmation", "-", "will", "attempt", "to", "sign", "server", "-", "side", "and", "set", "sequence", "numbers", "if", "no", "signatures", "are", "provided" ]

[ "func", "(", "ba", "*", "BlockAccumulator", ")", "Consume", "(", "ev", "*", "StreamEvent", ")", "*", "BlockExecution", "{", "switch", "{", "case", "ev", ".", "BeginBlock", "!=", "nil", ":", "ba", ".", "block", "=", "&", "BlockExecution", "{", "Height", ":", "ev", ".", "BeginBlock", ".", "Height", ",", "Header", ":", "ev", ".", "BeginBlock", ".", "Header", ",", "}", "\n", "case", "ev", ".", "BeginTx", "!=", "nil", ",", "ev", ".", "Envelope", "!=", "nil", ",", "ev", ".", "Event", "!=", "nil", ",", "ev", ".", "EndTx", "!=", "nil", ":", "txe", ":=", "ba", ".", "stack", ".", "Consume", "(", "ev", ")", "\n", "if", "txe", "!=", "nil", "{", "ba", ".", "block", ".", "TxExecutions", "=", "append", "(", "ba", ".", "block", ".", "TxExecutions", ",", "txe", ")", "\n", "}", "\n", "case", "ev", ".", "EndBlock", "!=", "nil", ":", "return", "ba", ".", "block", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Consume", "will", "add", "the", "StreamEvent", "passed", "to", "the", "block", "accumulator", "and", "if", "the", "block", "complete", "is", "complete", "return", "the", "BlockExecution", "otherwise", "will", "return", "nil" ]

[ "func", "(", "stack", "*", "TxStack", ")", "Consume", "(", "ev", "*", "StreamEvent", ")", "*", "TxExecution", "{", "switch", "{", "case", "ev", ".", "BeginTx", "!=", "nil", ":", "stack", ".", "Push", "(", "initTx", "(", "ev", ".", "BeginTx", ")", ")", "\n", "case", "ev", ".", "Envelope", "!=", "nil", ":", "txe", ":=", "stack", ".", "Peek", "(", ")", "\n", "txe", ".", "Envelope", "=", "ev", ".", "Envelope", "\n", "txe", ".", "Receipt", "=", "txe", ".", "Envelope", ".", "Tx", ".", "GenerateReceipt", "(", ")", "\n", "case", "ev", ".", "Event", "!=", "nil", ":", "txe", ":=", "stack", ".", "Peek", "(", ")", "\n", "txe", ".", "Events", "=", "append", "(", "txe", ".", "Events", ",", "ev", ".", "Event", ")", "\n", "case", "ev", ".", "EndTx", "!=", "nil", ":", "txe", ":=", "stack", ".", "Pop", "(", ")", "\n", "if", "len", "(", "*", "stack", ")", "==", "0", "{", "// This terminates the outermost transaction", "return", "txe", "\n", "}", "\n", "// If there is a parent tx on the stack add this tx as child", "parent", ":=", "stack", ".", "Peek", "(", ")", "\n", "parent", ".", "TxExecutions", "=", "append", "(", "parent", ".", "TxExecutions", ",", "txe", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Consume", "will", "add", "the", "StreamEvent", "to", "the", "transaction", "stack", "and", "if", "that", "completes", "a", "single", "outermost", "transaction", "returns", "the", "TxExecution", "otherwise", "will", "return", "nil" ]

[ "func", "Diff", "(", "before", ",", "after", "IterableReader", ")", "(", "*", "Set", ",", "error", ")", "{", "diff", ":=", "NewSet", "(", ")", "\n", "err", ":=", "after", ".", "IterateValidators", "(", "func", "(", "id", "crypto", ".", "Addressable", ",", "powerAfter", "*", "big", ".", "Int", ")", "error", "{", "powerBefore", ",", "err", ":=", "before", ".", "Power", "(", "id", ".", "GetAddress", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Exclude any powers from before that much after", "if", "powerBefore", ".", "Cmp", "(", "powerAfter", ")", "!=", "0", "{", "diff", ".", "ChangePower", "(", "id", ".", "GetPublicKey", "(", ")", ",", "powerAfter", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Make sure to zero any validators in before but not in after", "err", "=", "before", ".", "IterateValidators", "(", "func", "(", "id", "crypto", ".", "Addressable", ",", "powerBefore", "*", "big", ".", "Int", ")", "error", "{", "powerAfter", ",", "err", ":=", "after", ".", "Power", "(", "id", ".", "GetAddress", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// If there is a difference value then add to diff", "if", "powerAfter", ".", "Cmp", "(", "powerBefore", ")", "!=", "0", "{", "diff", ".", "ChangePower", "(", "id", ".", "GetPublicKey", "(", ")", ",", "powerAfter", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "diff", ",", "nil", "\n", "}" ]

[ "Returns", "the", "asymmetric", "difference", "diff", "between", "two", "Sets", "such", "that", "applying", "diff", "to", "before", "results", "in", "after" ]

[ "func", "Add", "(", "vs", "ReaderWriter", ",", "vsOther", "Iterable", ")", "error", "{", "return", "vsOther", ".", "IterateValidators", "(", "func", "(", "id", "crypto", ".", "Addressable", ",", "power", "*", "big", ".", "Int", ")", "error", "{", "return", "AddPower", "(", "vs", ",", "id", ".", "GetPublicKey", "(", ")", ",", "power", ")", "\n", "}", ")", "\n", "}" ]

[ "Adds", "vsOther", "to", "vs" ]

[ "func", "Subtract", "(", "vs", "ReaderWriter", ",", "vsOther", "Iterable", ")", "error", "{", "return", "vsOther", ".", "IterateValidators", "(", "func", "(", "id", "crypto", ".", "Addressable", ",", "power", "*", "big", ".", "Int", ")", "error", "{", "return", "SubtractPower", "(", "vs", ",", "id", ".", "GetPublicKey", "(", ")", ",", "power", ")", "\n", "}", ")", "\n", "}" ]

[ "Subtracts", "vsOther", "from", "vs" ]

[ "func", "ReflectTags", "(", "value", "interface", "{", "}", ",", "fieldNames", "...", "string", ")", "(", "*", "ReflectTagged", ",", "error", ")", "{", "rv", ":=", "reflect", ".", "ValueOf", "(", "value", ")", "\n", "if", "rv", ".", "IsNil", "(", ")", "{", "return", "&", "ReflectTagged", "{", "}", ",", "nil", "\n", "}", "\n", "if", "rv", ".", "Kind", "(", ")", "!=", "reflect", ".", "Ptr", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rv", ".", "Interface", "(", ")", ")", "\n", "}", "\n", "if", "rv", ".", "Elem", "(", ")", ".", "Kind", "(", ")", "!=", "reflect", ".", "Struct", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rv", ".", "Interface", "(", ")", ")", "\n", "}", "\n", "ty", ":=", "rv", ".", "Elem", "(", ")", ".", "Type", "(", ")", "\n", "// Try our global cache on types", "if", "rt", ",", "ok", ":=", "cache", ".", "get", "(", "ty", ",", "fieldNames", ")", ";", "ok", "{", "rt", ".", "rv", "=", "rv", "\n", "return", "rt", ",", "nil", "\n", "}", "\n\n", "numField", ":=", "ty", ".", "NumField", "(", ")", "\n", "if", "len", "(", "fieldNames", ")", ">", "0", "{", "if", "len", "(", "fieldNames", ")", ">", "numField", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "fieldNames", ")", ",", "rv", ".", "Interface", "(", ")", ",", "numField", ")", "\n", "}", "\n", "numField", "=", "len", "(", "fieldNames", ")", "\n", "}", "\n", "rt", ":=", "&", "ReflectTagged", "{", "rv", ":", "rv", ",", "ks", ":", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ",", "numField", ")", ",", "keys", ":", "make", "(", "[", "]", "string", ",", "0", ",", "numField", ")", ",", "}", "\n", "if", "len", "(", "fieldNames", ")", ">", "0", "{", "for", "_", ",", "fieldName", ":=", "range", "fieldNames", "{", "field", ",", "ok", ":=", "ty", ".", "FieldByName", "(", "fieldName", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fieldName", ",", "rv", ".", "Interface", "(", ")", ")", "\n", "}", "\n", "ok", "=", "rt", ".", "registerField", "(", "field", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fieldName", ",", "rv", ".", "Interface", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "for", "i", ":=", "0", ";", "i", "<", "numField", ";", "i", "++", "{", "rt", ".", "registerField", "(", "ty", ".", "Field", "(", "i", ")", ")", "\n", "}", "\n", "}", "\n", "// Cache the registration", "cache", ".", "put", "(", "ty", ",", "rt", ",", "fieldNames", ")", "\n", "return", "rt", ",", "nil", "\n", "}" ]

[ "ReflectTags", "provides", "a", "query", ".", "Tagged", "on", "a", "structs", "exported", "fields", "using", "query", ".", "StringFromValue", "to", "derive", "the", "string", "values", "associated", "with", "each", "field", ".", "If", "passed", "explicit", "field", "names", "will", "only", "only", "provide", "those", "fields", "as", "tags", "otherwise", "all", "exported", "fields", "are", "provided", "." ]

[ "func", "NewMemoryState", "(", ")", "*", "MemoryState", "{", "return", "&", "MemoryState", "{", "Accounts", ":", "make", "(", "map", "[", "crypto", ".", "Address", "]", "*", "acm", ".", "Account", ")", ",", "Storage", ":", "make", "(", "map", "[", "crypto", ".", "Address", "]", "map", "[", "binary", ".", "Word256", "]", "binary", ".", "Word256", ")", ",", "}", "\n", "}" ]

[ "Get", "an", "in", "-", "memory", "state", "IterableReader" ]

[ "func", "ValuesAndContext", "(", "keyvals", "[", "]", "interface", "{", "}", ",", "keys", "...", "interface", "{", "}", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "[", "]", "interface", "{", "}", ")", "{", "vals", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "len", "(", "keys", ")", ")", "\n", "context", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "len", "(", "keyvals", ")", ")", "\n", "copy", "(", "context", ",", "keyvals", ")", "\n", "deletions", ":=", "0", "\n", "// We can't really do better than a linear scan of both lists here. N is small", "// so screw the asymptotics.", "// Guard against odd-length list", "for", "i", ":=", "0", ";", "i", "<", "2", "*", "(", "len", "(", "keyvals", ")", "/", "2", ")", ";", "i", "+=", "2", "{", "for", "k", ":=", "0", ";", "k", "<", "len", "(", "keys", ")", ";", "k", "++", "{", "if", "keyvals", "[", "i", "]", "==", "keys", "[", "k", "]", "{", "// Pull the matching key-value pair into vals to return", "vals", "[", "StringifyKey", "(", "keys", "[", "k", "]", ")", "]", "=", "keyvals", "[", "i", "+", "1", "]", "\n", "// Delete the key once it's found", "keys", "=", "DeleteAt", "(", "keys", ",", "k", ")", "\n", "// And remove the key-value pair from context", "context", "=", "Delete", "(", "context", ",", "i", "-", "deletions", ",", "2", ")", "\n", "// Keep a track of how much we've shrunk the context to offset next", "// deletion", "deletions", "+=", "2", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "vals", ",", "context", "\n", "}" ]

[ "Pull", "the", "specified", "values", "from", "a", "structured", "log", "line", "into", "a", "map", ".", "Assumes", "keys", "are", "single", "-", "valued", ".", "Returns", "a", "map", "of", "the", "key", "-", "values", "from", "the", "requested", "keys", "and", "the", "unmatched", "remainder", "keyvals", "as", "context", "as", "a", "slice", "of", "key", "-", "values", "." ]

[ "func", "KeyValuesMap", "(", "keyvals", "[", "]", "interface", "{", "}", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "length", ":=", "len", "(", "keyvals", ")", "/", "2", "\n", "vals", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "length", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "2", "*", "length", ";", "i", "+=", "2", "{", "vals", "[", "StringifyKey", "(", "keyvals", "[", "i", "]", ")", "]", "=", "keyvals", "[", "i", "+", "1", "]", "\n", "}", "\n", "return", "vals", "\n", "}" ]

[ "Returns", "keyvals", "as", "a", "map", "from", "keys", "to", "vals" ]

[ "func", "DropKeys", "(", "keyvals", "[", "]", "interface", "{", "}", ",", "dropKeyValPredicate", "func", "(", "key", ",", "value", "interface", "{", "}", ")", "bool", ")", "[", "]", "interface", "{", "}", "{", "keyvalsDropped", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "len", "(", "keyvals", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "2", "*", "(", "len", "(", "keyvals", ")", "/", "2", ")", ";", "i", "+=", "2", "{", "if", "!", "dropKeyValPredicate", "(", "keyvals", "[", "i", "]", ",", "keyvals", "[", "i", "+", "1", "]", ")", "{", "keyvalsDropped", "=", "append", "(", "keyvalsDropped", ",", "keyvals", "[", "i", "]", ",", "keyvals", "[", "i", "+", "1", "]", ")", "\n", "}", "\n", "}", "\n", "return", "keyvalsDropped", "\n", "}" ]

[ "Drops", "all", "key", "value", "pairs", "where", "dropKeyValPredicate", "is", "true" ]

[ "func", "Vectorise", "(", "keyvals", "[", "]", "interface", "{", "}", ",", "vectorKeys", "...", "string", ")", "[", "]", "interface", "{", "}", "{", "// We rely on working against a single backing array, so we use a capacity that is the maximum possible size of the", "// slice after vectorising (in the case there are no duplicate keys and this is a no-op)", "outputKeyvals", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "len", "(", "keyvals", ")", ")", "\n", "// Track the location and vector status of the values in the output", "valueIndices", ":=", "make", "(", "map", "[", "string", "]", "*", "vectorValueindex", ",", "len", "(", "vectorKeys", ")", ")", "\n", "elided", ":=", "0", "\n", "for", "i", ":=", "0", ";", "i", "<", "2", "*", "(", "len", "(", "keyvals", ")", "/", "2", ")", ";", "i", "+=", "2", "{", "key", ":=", "keyvals", "[", "i", "]", "\n", "val", ":=", "keyvals", "[", "i", "+", "1", "]", "\n\n", "// Only attempt to vectorise string keys", "if", "k", ",", "ok", ":=", "key", ".", "(", "string", ")", ";", "ok", "{", "if", "valueIndices", "[", "k", "]", "==", "nil", "{", "// Record that this key has been seen once", "valueIndices", "[", "k", "]", "=", "&", "vectorValueindex", "{", "valueIndex", ":", "i", "+", "1", "-", "elided", ",", "}", "\n", "// Copy the key-value to output with the single value", "outputKeyvals", "=", "append", "(", "outputKeyvals", ",", "key", ",", "val", ")", "\n", "}", "else", "{", "// We have seen this key before", "vi", ":=", "valueIndices", "[", "k", "]", "\n", "if", "!", "vi", ".", "vector", "{", "// This must be the only second occurrence of the key so now vectorise the value", "outputKeyvals", "[", "vi", ".", "valueIndex", "]", "=", "Vector", "(", "[", "]", "interface", "{", "}", "{", "outputKeyvals", "[", "vi", ".", "valueIndex", "]", "}", ")", "\n", "vi", ".", "vector", "=", "true", "\n", "}", "\n", "// Grow the vector value", "outputKeyvals", "[", "vi", ".", "valueIndex", "]", "=", "append", "(", "outputKeyvals", "[", "vi", ".", "valueIndex", "]", ".", "(", "Vector", ")", ",", "val", ")", "\n", "// We are now running two more elements behind the input keyvals because we have absorbed this key-value pair", "elided", "+=", "2", "\n", "}", "\n", "}", "else", "{", "// Just copy the key-value to the output for non-string keys", "outputKeyvals", "=", "append", "(", "outputKeyvals", ",", "key", ",", "val", ")", "\n", "}", "\n", "}", "\n", "return", "outputKeyvals", "\n", "}" ]

[ "Vectorises", "values", "associated", "with", "repeated", "string", "keys", "member", "by", "collapsing", "many", "values", "into", "a", "single", "vector", "value", ".", "The", "result", "is", "a", "copy", "of", "keyvals", "where", "the", "first", "occurrence", "of", "each", "matching", "key", "and", "its", "first", "value", "are", "replaced", "by", "that", "key", "and", "all", "of", "its", "values", "in", "a", "single", "slice", "." ]

[ "func", "Value", "(", "keyvals", "[", "]", "interface", "{", "}", ",", "key", "interface", "{", "}", ")", "interface", "{", "}", "{", "for", "i", ":=", "0", ";", "i", "<", "2", "*", "(", "len", "(", "keyvals", ")", "/", "2", ")", ";", "i", "+=", "2", "{", "if", "keyvals", "[", "i", "]", "==", "key", "{", "return", "keyvals", "[", "i", "+", "1", "]", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Return", "a", "single", "value", "corresponding", "to", "key", "in", "keyvals" ]

[ "func", "StringifyKey", "(", "key", "interface", "{", "}", ")", "string", "{", "switch", "key", "{", "// For named keys we want to handle explicitly", "default", ":", "// Stringify keys", "switch", "k", ":=", "key", ".", "(", "type", ")", "{", "case", "string", ":", "return", "k", "\n", "case", "fmt", ".", "Stringer", ":", "return", "k", ".", "String", "(", ")", "\n", "default", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Provides", "a", "canonical", "way", "to", "stringify", "keys" ]

[ "func", "Signal", "(", "keyvals", "[", "]", "interface", "{", "}", ")", "string", "{", "last", ":=", "len", "(", "keyvals", ")", "-", "1", "\n", "if", "last", ">", "0", "&&", "keyvals", "[", "last", "-", "1", "]", "==", "SignalKey", "{", "signal", ",", "ok", ":=", "keyvals", "[", "last", "]", ".", "(", "string", ")", "\n", "if", "ok", "{", "return", "signal", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "Tried", "to", "interpret", "the", "logline", "as", "a", "signal", "by", "matching", "the", "last", "key", "-", "value", "pair", "as", "a", "signal", "returns", "empty", "string", "if", "no", "match", ".", "The", "idea", "with", "signals", "is", "that", "the", "should", "be", "transmitted", "to", "a", "root", "logger", "as", "a", "single", "key", "-", "value", "pair", "so", "we", "avoid", "the", "need", "to", "do", "a", "linear", "probe", "over", "every", "log", "line", "in", "order", "to", "detect", "a", "signal", "." ]

[ "func", "(", "be", "*", "BlockExecution", ")", "StreamEvents", "(", ")", "StreamEvents", "{", "var", "ses", "StreamEvents", "\n", "ses", "=", "append", "(", "ses", ",", "&", "StreamEvent", "{", "BeginBlock", ":", "&", "BeginBlock", "{", "Height", ":", "be", ".", "Height", ",", "Header", ":", "be", ".", "Header", ",", "}", ",", "}", ")", "\n", "for", "_", ",", "txe", ":=", "range", "be", ".", "TxExecutions", "{", "ses", "=", "append", "(", "ses", ",", "txe", ".", "StreamEvents", "(", ")", "...", ")", "\n", "}", "\n", "return", "append", "(", "ses", ",", "&", "StreamEvent", "{", "EndBlock", ":", "&", "EndBlock", "{", "Height", ":", "be", ".", "Height", ",", "}", ",", "}", ")", "\n", "}" ]

[ "Write", "out", "TxExecutions", "parenthetically" ]

[ "func", "(", "kvc", "*", "KVCache", ")", "WriteTo", "(", "writer", "KVWriter", ")", "{", "kvc", ".", "Lock", "(", ")", "\n", "defer", "kvc", ".", "Unlock", "(", ")", "\n", "for", "k", ",", "vi", ":=", "range", "kvc", ".", "cache", "{", "kb", ":=", "[", "]", "byte", "(", "k", ")", "\n", "if", "vi", ".", "deleted", "{", "writer", ".", "Delete", "(", "kb", ")", "\n", "}", "else", "{", "writer", ".", "Set", "(", "kb", ",", "vi", ".", "value", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Writes", "contents", "of", "cache", "to", "backend", "without", "flushing", "the", "cache" ]

[ "func", "NewEmitter", "(", ")", "*", "Emitter", "{", "pubsubServer", ":=", "pubsub", ".", "NewServer", "(", "pubsub", ".", "BufferCapacity", "(", "DefaultEventBufferCapacity", ")", ")", "\n", "pubsubServer", ".", "BaseService", "=", "*", "common", ".", "NewBaseService", "(", "nil", ",", "\"", "\"", ",", "pubsubServer", ")", "\n", "pubsubServer", ".", "Start", "(", ")", "\n", "return", "&", "Emitter", "{", "pubsubServer", ":", "pubsubServer", ",", "}", "\n", "}" ]

[ "NewEmitter", "initializes", "an", "emitter", "struct", "with", "a", "pubsubServer" ]

[ "func", "(", "em", "*", "Emitter", ")", "SetLogger", "(", "logger", "*", "logging", ".", "Logger", ")", "{", "em", ".", "logger", "=", "logger", ".", "With", "(", "structure", ".", "ComponentKey", ",", "\"", "\"", ")", "\n", "}" ]

[ "SetLogger", "attaches", "a", "log", "handler", "to", "this", "emitter" ]

[ "func", "(", "em", "*", "Emitter", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "error", "{", "return", "em", ".", "pubsubServer", ".", "Stop", "(", ")", "\n", "}" ]

[ "Shutdown", "stops", "the", "pubsubServer" ]

[ "func", "(", "em", "*", "Emitter", ")", "Publish", "(", "ctx", "context", ".", "Context", ",", "message", "interface", "{", "}", ",", "tags", "query", ".", "Tagged", ")", "error", "{", "if", "em", "==", "nil", "||", "em", ".", "pubsubServer", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "em", ".", "pubsubServer", ".", "PublishWithTags", "(", "ctx", ",", "message", ",", "tags", ")", "\n", "}" ]

[ "Publish", "tells", "the", "emitter", "to", "publish", "with", "the", "given", "message", "and", "tags" ]

[ "func", "(", "em", "*", "Emitter", ")", "Subscribe", "(", "ctx", "context", ".", "Context", ",", "subscriber", "string", ",", "queryable", "query", ".", "Queryable", ",", "bufferSize", "int", ")", "(", "<-", "chan", "interface", "{", "}", ",", "error", ")", "{", "qry", ",", "err", ":=", "queryable", ".", "Query", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "em", ".", "pubsubServer", ".", "Subscribe", "(", "ctx", ",", "subscriber", ",", "qry", ",", "bufferSize", ")", "\n", "}" ]

[ "Subscribe", "tells", "the", "emitter", "to", "listen", "for", "messages", "on", "the", "given", "query" ]

[ "func", "(", "em", "*", "Emitter", ")", "Unsubscribe", "(", "ctx", "context", ".", "Context", ",", "subscriber", "string", ",", "queryable", "query", ".", "Queryable", ")", "error", "{", "pubsubQuery", ",", "err", ":=", "queryable", ".", "Query", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "em", ".", "pubsubServer", ".", "Unsubscribe", "(", "ctx", ",", "subscriber", ",", "pubsubQuery", ")", "\n", "}" ]

[ "Unsubscribe", "tells", "the", "emitter", "to", "stop", "listening", "for", "said", "messages" ]

[ "func", "(", "em", "*", "Emitter", ")", "UnsubscribeAll", "(", "ctx", "context", ".", "Context", ",", "subscriber", "string", ")", "error", "{", "return", "em", ".", "pubsubServer", ".", "UnsubscribeAll", "(", "ctx", ",", "subscriber", ")", "\n", "}" ]

[ "UnsubscribeAll", "just", "stop", "listening", "for", "all", "messages" ]

[ "func", "(", "cl", "*", "CaptureLogger", ")", "SetPassthrough", "(", "passthrough", "bool", ")", "{", "cl", ".", "Lock", "(", ")", "\n", "defer", "cl", ".", "Unlock", "(", ")", "\n", "cl", ".", "passthrough", "=", "passthrough", "\n", "}" ]

[ "Sets", "whether", "the", "CaptureLogger", "is", "forwarding", "log", "lines", "sent", "to", "it", "through", "to", "its", "output", "logger", ".", "Concurrently", "safe", "." ]

[ "func", "(", "cl", "*", "CaptureLogger", ")", "Passthrough", "(", ")", "bool", "{", "cl", ".", "RLock", "(", ")", "\n", "defer", "cl", ".", "RUnlock", "(", ")", "\n", "return", "cl", ".", "passthrough", "\n", "}" ]

[ "Gets", "whether", "the", "CaptureLogger", "is", "forwarding", "log", "lines", "sent", "to", "through", "to", "its", "OutputLogger", ".", "Concurrently", "Safe", "." ]

[ "func", "main", "(", ")", "{", "loggingConfig", ":=", "&", "LoggingConfig", "{", "RootSink", ":", "Sink", "(", ")", ".", "AddSinks", "(", "// Log everything to Stderr", "Sink", "(", ")", ".", "SetOutput", "(", "StderrOutput", "(", ")", ")", ",", "Sink", "(", ")", ".", "SetTransform", "(", "FilterTransform", "(", "ExcludeWhenAllMatch", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ")", ".", "AddSinks", "(", "Sink", "(", ")", ".", "SetOutput", "(", "StdoutOutput", "(", ")", ")", ",", ")", ",", ")", ",", "}", "\n", "fmt", ".", "Println", "(", "loggingConfig", ".", "RootTOMLString", "(", ")", ")", "\n", "}" ]

[ "Dump", "an", "example", "logging", "configuration" ]

[ "func", "NewLogger", "(", "outputLogger", "log", ".", "Logger", ")", "*", "Logger", "{", "// We will never halt the progress of a log emitter. If log output takes too", "// long will start dropping log lines by using a ring buffer.", "swapLogger", ":=", "new", "(", "log", ".", "SwapLogger", ")", "\n", "swapLogger", ".", "Swap", "(", "outputLogger", ")", "\n", "return", "&", "Logger", "{", "Output", ":", "swapLogger", ",", "// logging contexts", "Info", ":", "log", ".", "With", "(", "swapLogger", ",", "structure", ".", "ChannelKey", ",", "structure", ".", "InfoChannelName", ",", ")", ",", "Trace", ":", "log", ".", "With", "(", "swapLogger", ",", "structure", ".", "ChannelKey", ",", "structure", ".", "TraceChannelName", ",", ")", ",", "}", "\n", "}" ]

[ "Create", "an", "InfoTraceLogger", "by", "passing", "the", "initial", "outputLogger", "." ]

[ "func", "(", "l", "*", "Logger", ")", "SwapOutput", "(", "infoLogger", "log", ".", "Logger", ")", "{", "l", ".", "Output", ".", "Swap", "(", "infoLogger", ")", "\n", "}" ]

[ "Hot", "swap", "the", "underlying", "outputLogger", "with", "another", "one", "to", "re", "-", "route", "messages" ]

[ "func", "(", "l", "*", "Logger", ")", "InfoMsg", "(", "message", "string", ",", "keyvals", "...", "interface", "{", "}", ")", "error", "{", "return", "Msg", "(", "l", ".", "Info", ",", "message", ",", "keyvals", "...", ")", "\n", "}" ]

[ "Record", "structured", "Info", "lo", "g", "line", "with", "a", "message" ]

[ "func", "(", "l", "*", "Logger", ")", "TraceMsg", "(", "message", "string", ",", "keyvals", "...", "interface", "{", "}", ")", "error", "{", "return", "Msg", "(", "l", ".", "Trace", ",", "message", ",", "keyvals", "...", ")", "\n", "}" ]

[ "Record", "structured", "Trace", "log", "line", "with", "a", "message" ]

[ "func", "(", "l", "*", "Logger", ")", "WithScope", "(", "scopeName", "string", ")", "*", "Logger", "{", "// InfoTraceLogger will collapse successive (ScopeKey, scopeName) pairs into a vector in the order which they appear", "return", "l", ".", "With", "(", "structure", ".", "ScopeKey", ",", "scopeName", ")", "\n", "}" ]

[ "Establish", "or", "extend", "the", "scope", "of", "this", "logger", "by", "appending", "scopeName", "to", "the", "Scope", "vector", ".", "Like", "With", "the", "logging", "scope", "is", "append", "only", "but", "can", "be", "used", "to", "provide", "parenthetical", "scopes", "by", "hanging", "on", "to", "the", "parent", "scope", "and", "using", "once", "the", "scope", "has", "been", "exited", ".", "The", "scope", "mechanism", "does", "is", "agnostic", "to", "the", "type", "of", "scope", "so", "can", "be", "used", "to", "identify", "certain", "segments", "of", "the", "call", "stack", "a", "lexical", "scope", "or", "any", "other", "nested", "scope", "." ]

[ "func", "Msg", "(", "logger", "log", ".", "Logger", ",", "message", "string", ",", "keyvals", "...", "interface", "{", "}", ")", "error", "{", "prepended", ":=", "structure", ".", "CopyPrepend", "(", "keyvals", ",", "structure", ".", "MessageKey", ",", "message", ")", "\n", "return", "logger", ".", "Log", "(", "prepended", "...", ")", "\n", "}" ]

[ "Record", "a", "structured", "log", "line", "with", "a", "message" ]

[ "func", "(", "d", "*", "digest", ")", "unalignedAbsorb", "(", "p", "[", "]", "byte", ")", "{", "var", "t", "uint64", "\n", "for", "i", ":=", "len", "(", "p", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "t", "<<=", "8", "\n", "t", "|=", "uint64", "(", "p", "[", "i", "]", ")", "\n", "}", "\n", "offset", ":=", "(", "d", ".", "absorbed", ")", "%", "d", ".", "rate", "(", ")", "\n", "t", "<<=", "8", "*", "uint", "(", "offset", "%", "laneSize", ")", "\n", "d", ".", "a", "[", "offset", "/", "laneSize", "]", "^=", "t", "\n", "d", ".", "absorbed", "+=", "len", "(", "p", ")", "\n", "}" ]

[ "unalignedAbsorb", "is", "a", "helper", "function", "for", "Write", "which", "absorbs", "data", "that", "isn", "t", "aligned", "with", "an", "8", "-", "byte", "lane", ".", "This", "requires", "shifting", "the", "individual", "bytes", "into", "position", "in", "a", "uint64", "." ]

[ "func", "(", "d", "*", "digest", ")", "Sum", "(", "in", "[", "]", "byte", ")", "[", "]", "byte", "{", "// Make a copy of the original hash so that caller can keep writing and summing.", "dup", ":=", "*", "d", "\n", "dup", ".", "finalize", "(", ")", "\n", "return", "dup", ".", "squeeze", "(", "in", ",", "dup", ".", "outputSize", ")", "\n", "}" ]

[ "Sum", "applies", "padding", "to", "the", "hash", "state", "and", "then", "squeezes", "out", "the", "desired", "nubmer", "of", "output", "bytes", "." ]

[ "func", "NewLoggerFromLoggingConfig", "(", "loggingConfig", "*", "logconfig", ".", "LoggingConfig", ")", "(", "*", "logging", ".", "Logger", ",", "error", ")", "{", "if", "loggingConfig", "==", "nil", "{", "return", "NewStdErrLogger", "(", ")", "\n", "}", "else", "{", "outputLogger", ",", "errCh", ",", "err", ":=", "loggerFromLoggingConfig", "(", "loggingConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "logger", ":=", "logging", ".", "NewLogger", "(", "outputLogger", ")", "\n", "if", "!", "loggingConfig", ".", "Trace", "{", "logger", ".", "Trace", "=", "log", ".", "NewNopLogger", "(", ")", "\n", "}", "\n", "go", "func", "(", ")", "{", "err", ":=", "<-", "errCh", ".", "Out", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "logger", ",", "nil", "\n", "}", "\n", "}" ]

[ "Lifecycle", "provides", "a", "canonical", "source", "for", "burrow", "loggers", ".", "Components", "should", "use", "the", "functions", "here", "to", "set", "up", "their", "root", "logger", "and", "capture", "any", "other", "logging", "output", ".", "Obtain", "a", "logger", "from", "a", "LoggingConfig" ]

[ "func", "SwapOutputLoggersFromLoggingConfig", "(", "logger", "*", "logging", ".", "Logger", ",", "loggingConfig", "*", "logconfig", ".", "LoggingConfig", ")", "(", "error", ",", "channels", ".", "Channel", ")", "{", "outputLogger", ",", "errCh", ",", "err", ":=", "loggerFromLoggingConfig", "(", "loggingConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", ",", "channels", ".", "NewDeadChannel", "(", ")", "\n", "}", "\n", "logger", ".", "SwapOutput", "(", "outputLogger", ")", "\n", "return", "nil", ",", "errCh", "\n", "}" ]

[ "Hot", "swap", "logging", "config", "by", "replacing", "output", "loggers", "of", "passed", "InfoTraceLogger", "with", "those", "built", "from", "loggingConfig" ]

[ "func", "MergeAbiSpec", "(", "abiSpec", "[", "]", "*", "AbiSpec", ")", "*", "AbiSpec", "{", "newSpec", ":=", "AbiSpec", "{", "Events", ":", "make", "(", "map", "[", "string", "]", "EventSpec", ")", ",", "EventsById", ":", "make", "(", "map", "[", "EventID", "]", "EventSpec", ")", ",", "Functions", ":", "make", "(", "map", "[", "string", "]", "FunctionSpec", ")", ",", "}", "\n\n", "for", "_", ",", "s", ":=", "range", "abiSpec", "{", "for", "n", ",", "f", ":=", "range", "s", ".", "Functions", "{", "newSpec", ".", "Functions", "[", "n", "]", "=", "f", "\n", "}", "\n\n", "// Different Abis can have the Event name, but with a different signature", "// Loop over the signatures, as these are less likely to have collisions", "for", "_", ",", "e", ":=", "range", "s", ".", "EventsById", "{", "newSpec", ".", "Events", "[", "e", ".", "Name", "]", "=", "e", "\n", "newSpec", ".", "EventsById", "[", "e", ".", "EventID", "]", "=", "e", "\n", "}", "\n", "}", "\n\n", "return", "&", "newSpec", "\n", "}" ]

[ "MergeAbiSpec", "takes", "multiple", "AbiSpecs", "and", "merges", "them", "into", "once", "structure", ".", "Note", "that", "the", "same", "function", "name", "or", "event", "name", "can", "occur", "in", "different", "abis", "so", "there", "might", "be", "some", "information", "loss", "." ]

[ "func", "UnpackRevert", "(", "data", "[", "]", "byte", ")", "(", "message", "*", "string", ",", "err", "error", ")", "{", "if", "len", "(", "data", ")", ">", "0", "{", "var", "msg", "string", "\n", "err", "=", "RevertAbi", ".", "UnpackWithID", "(", "data", ",", "&", "msg", ")", "\n", "message", "=", "&", "msg", "\n", "}", "\n", "return", "\n", "}" ]

[ "UnpackRevert", "decodes", "the", "revert", "reason", "if", "a", "contract", "called", "revert", ".", "If", "no", "reason", "was", "given", "message", "will", "be", "nil", "else", "it", "will", "point", "to", "the", "string" ]

[ "func", "pad", "(", "input", "[", "]", "byte", ",", "size", "int", ",", "left", "bool", ")", "[", "]", "byte", "{", "if", "len", "(", "input", ")", ">=", "size", "{", "return", "input", "[", ":", "size", "]", "\n", "}", "\n", "padded", ":=", "make", "(", "[", "]", "byte", ",", "size", ")", "\n", "if", "left", "{", "copy", "(", "padded", "[", "size", "-", "len", "(", "input", ")", ":", "]", ",", "input", ")", "\n", "}", "else", "{", "copy", "(", "padded", ",", "input", ")", "\n", "}", "\n", "return", "padded", "\n", "}" ]

[ "quick", "helper", "padding" ]

[ "func", "(", "bp", "BasePermissions", ")", "Get", "(", "ty", "PermFlag", ")", "(", "bool", ",", "error", ")", "{", "if", "ty", "==", "0", "{", "return", "false", ",", "ErrInvalidPermission", "(", "ty", ")", "\n", "}", "\n", "if", "!", "bp", ".", "IsSet", "(", "ty", ")", "{", "return", "false", ",", "ErrValueNotSet", "(", "ty", ")", "\n", "}", "\n", "return", "bp", ".", "Perms", "&", "ty", "==", "ty", ",", "nil", "\n", "}" ]

[ "Gets", "the", "permission", "value", ".", "ErrValueNotSet", "is", "returned", "if", "the", "permission", "s", "set", "bits", "are", "not", "all", "on", "and", "should", "be", "caught", "by", "caller", "so", "the", "global", "permission", "can", "be", "fetched" ]

[ "func", "(", "bp", "*", "BasePermissions", ")", "Set", "(", "ty", "PermFlag", ",", "value", "bool", ")", "error", "{", "if", "ty", "==", "0", "{", "return", "ErrInvalidPermission", "(", "ty", ")", "\n", "}", "\n", "bp", ".", "SetBit", "|=", "ty", "\n", "if", "value", "{", "bp", ".", "Perms", "|=", "ty", "\n", "}", "else", "{", "bp", ".", "Perms", "&=", "^", "ty", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Set", "a", "permission", "bit", ".", "Will", "set", "the", "permission", "s", "set", "bit", "to", "true", "." ]

[ "func", "(", "bp", "*", "BasePermissions", ")", "Unset", "(", "ty", "PermFlag", ")", "error", "{", "if", "ty", "==", "0", "{", "return", "ErrInvalidPermission", "(", "ty", ")", "\n", "}", "\n", "bp", ".", "SetBit", "&=", "^", "ty", "\n", "return", "nil", "\n", "}" ]

[ "Set", "the", "permission", "s", "set", "bits", "to", "false" ]

[ "func", "(", "bp", "BasePermissions", ")", "IsSet", "(", "ty", "PermFlag", ")", "bool", "{", "if", "ty", "==", "0", "{", "return", "false", "\n", "}", "\n", "return", "bp", ".", "SetBit", "&", "ty", "==", "ty", "\n", "}" ]

[ "Check", "if", "the", "permission", "is", "set" ]

[ "func", "(", "bp", "BasePermissions", ")", "Compose", "(", "bpFallthrough", "BasePermissions", ")", "BasePermissions", "{", "return", "BasePermissions", "{", "// Combine set perm flags from bp with set perm flags in fallthrough NOT set in bp", "Perms", ":", "(", "bp", ".", "Perms", "&", "bp", ".", "SetBit", ")", "|", "(", "bpFallthrough", ".", "Perms", "&", "(", "^", "bp", ".", "SetBit", "&", "bpFallthrough", ".", "SetBit", ")", ")", ",", "SetBit", ":", "bp", ".", "SetBit", "|", "bpFallthrough", ".", "SetBit", ",", "}", "\n", "}" ]

[ "Returns", "a", "BasePermission", "that", "matches", "any", "permissions", "set", "on", "this", "BasePermission", "and", "falls", "through", "to", "any", "permissions", "set", "on", "the", "bpFallthrough" ]

[ "func", "NewKernel", "(", "dbDir", "string", ")", "(", "*", "Kernel", ",", "error", ")", "{", "if", "dbDir", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "runID", ",", "err", ":=", "simpleuuid", ".", "NewTime", "(", "time", ".", "Now", "(", ")", ")", "// Create a random ID based on start time", "\n", "return", "&", "Kernel", "{", "Logger", ":", "logging", ".", "NewNoopLogger", "(", ")", ",", "RunID", ":", "runID", ",", "Emitter", ":", "event", ".", "NewEmitter", "(", ")", ",", "processes", ":", "make", "(", "map", "[", "string", "]", "process", ".", "Process", ")", ",", "listeners", ":", "make", "(", "map", "[", "string", "]", "net", ".", "Listener", ")", ",", "shutdownNotify", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "txCodec", ":", "txs", ".", "NewAminoCodec", "(", ")", ",", "database", ":", "dbm", ".", "NewDB", "(", "BurrowDBName", ",", "dbm", ".", "GoLevelDBBackend", ",", "dbDir", ")", ",", "}", ",", "err", "\n", "}" ]

[ "NewKernel", "initializes", "an", "empty", "kernel" ]

[ "func", "(", "kern", "*", "Kernel", ")", "SetLogger", "(", "logger", "*", "logging", ".", "Logger", ")", "{", "logger", "=", "logger", ".", "WithScope", "(", "\"", "\"", ")", ".", "With", "(", "structure", ".", "TimeKey", ",", "log", ".", "DefaultTimestampUTC", ",", "structure", ".", "RunId", ",", "kern", ".", "RunID", ".", "String", "(", ")", ")", "\n", "heightValuer", ":=", "log", ".", "Valuer", "(", "func", "(", ")", "interface", "{", "}", "{", "return", "kern", ".", "Blockchain", ".", "LastBlockHeight", "(", ")", "}", ")", "\n", "kern", ".", "Logger", "=", "logger", ".", "WithInfo", "(", "structure", ".", "CallerKey", ",", "log", ".", "Caller", "(", "LoggingCallerDepth", ")", ")", ".", "With", "(", "\"", "\"", ",", "heightValuer", ")", "\n", "kern", ".", "Emitter", ".", "SetLogger", "(", "logger", ")", "\n", "}" ]

[ "SetLogger", "initializes", "the", "kernel", "with", "the", "provided", "logger" ]

[ "func", "(", "kern", "*", "Kernel", ")", "LoadState", "(", "genesisDoc", "*", "genesis", ".", "GenesisDoc", ")", "(", "err", "error", ")", "{", "var", "existing", "bool", "\n", "existing", ",", "kern", ".", "Blockchain", ",", "err", "=", "bcm", ".", "LoadOrNewBlockchain", "(", "kern", ".", "database", ",", "genesisDoc", ",", "kern", ".", "Logger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "existing", "{", "kern", ".", "Logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "kern", ".", "Blockchain", ".", "LastBlockHeight", "(", ")", ")", "\n", "kern", ".", "State", ",", "err", "=", "state", ".", "LoadState", "(", "kern", ".", "database", ",", "execution", ".", "VersionAtHeight", "(", "kern", ".", "Blockchain", ".", "LastBlockHeight", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "kern", ".", "Blockchain", ".", "AppHashAfterLastBlock", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "!", "bytes", ".", "Equal", "(", "kern", ".", "State", ".", "Hash", "(", ")", ",", "kern", ".", "Blockchain", ".", "AppHashAfterLastBlock", "(", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "kern", ".", "Blockchain", ".", "LastBlockHeight", "(", ")", ",", "kern", ".", "State", ".", "Hash", "(", ")", ",", "kern", ".", "Blockchain", ".", "AppHashAfterLastBlock", "(", ")", ")", "\n", "}", "\n\n", "}", "else", "{", "kern", ".", "Logger", ".", "InfoMsg", "(", "\"", "\"", ")", "\n", "kern", ".", "State", ",", "err", "=", "state", ".", "MakeGenesisState", "(", "kern", ".", "database", ",", "genesisDoc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "kern", ".", "State", ".", "InitialCommit", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "kern", ".", "Logger", ".", "InfoMsg", "(", "\"", "\"", ")", "\n\n", "params", ":=", "execution", ".", "ParamsFromGenesis", "(", "genesisDoc", ")", "\n", "kern", ".", "checker", "=", "execution", ".", "NewBatchChecker", "(", "kern", ".", "State", ",", "params", ",", "kern", ".", "Blockchain", ",", "kern", ".", "Logger", ")", "\n", "kern", ".", "committer", "=", "execution", ".", "NewBatchCommitter", "(", "kern", ".", "State", ",", "params", ",", "kern", ".", "Blockchain", ",", "kern", ".", "Emitter", ",", "kern", ".", "Logger", ",", "kern", ".", "exeOptions", "...", ")", "\n", "return", "nil", "\n", "}" ]

[ "LoadState", "starts", "from", "scratch", "or", "previous", "chain" ]

[ "func", "(", "kern", "*", "Kernel", ")", "LoadDump", "(", "genesisDoc", "*", "genesis", ".", "GenesisDoc", ",", "restoreFile", "string", ",", "silent", "bool", ")", "(", "err", "error", ")", "{", "var", "exists", "bool", "\n", "if", "exists", ",", "kern", ".", "Blockchain", ",", "err", "=", "bcm", ".", "LoadOrNewBlockchain", "(", "kern", ".", "database", ",", "genesisDoc", ",", "kern", ".", "Logger", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "exists", "{", "if", "silent", "{", "kern", ".", "Logger", ".", "InfoMsg", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "kern", ".", "Blockchain", ".", "SetBlockStore", "(", "bcm", ".", "NewBlockStore", "(", "blockchain", ".", "NewBlockStore", "(", "kern", ".", "database", ")", ")", ")", "\n\n", "if", "kern", ".", "State", ",", "err", "=", "state", ".", "MakeGenesisState", "(", "kern", ".", "database", ",", "genesisDoc", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "len", "(", "genesisDoc", ".", "AppHash", ")", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "reader", ",", "err", ":=", "state", ".", "NewFileDumpReader", "(", "restoreFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "kern", ".", "State", ".", "LoadDump", "(", "reader", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "kern", ".", "State", ".", "InitialCommit", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "!", "bytes", ".", "Equal", "(", "kern", ".", "State", ".", "Hash", "(", ")", ",", "kern", ".", "Blockchain", ".", "GenesisDoc", "(", ")", ".", "AppHash", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "kern", ".", "Blockchain", ".", "GenesisDoc", "(", ")", ".", "AppHash", ",", "kern", ".", "State", ".", "Hash", "(", ")", ")", "\n", "}", "\n", "err", "=", "kern", ".", "Blockchain", ".", "CommitWithAppHash", "(", "kern", ".", "State", ".", "Hash", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "kern", ".", "Logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "kern", ".", "State", ".", "Hash", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "LoadDump", "restores", "chain", "state", "from", "the", "given", "dump", "file" ]

[ "func", "(", "kern", "*", "Kernel", ")", "GetNodeView", "(", ")", "(", "*", "tendermint", ".", "NodeView", ",", "error", ")", "{", "if", "kern", ".", "Node", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "tendermint", ".", "NewNodeView", "(", "kern", ".", "Node", ",", "kern", ".", "txCodec", ",", "kern", ".", "RunID", ")", "\n", "}" ]

[ "GetNodeView", "builds", "and", "returns", "a", "wrapper", "of", "our", "tendermint", "node" ]

[ "func", "(", "kern", "*", "Kernel", ")", "AddExecutionOptions", "(", "opts", "...", "execution", ".", "ExecutionOption", ")", "{", "kern", ".", "exeOptions", "=", "append", "(", "kern", ".", "exeOptions", ",", "opts", "...", ")", "\n", "}" ]

[ "AddExecutionOptions", "extends", "our", "execution", "options" ]

[ "func", "(", "kern", "*", "Kernel", ")", "AddProcesses", "(", "pl", "...", "process", ".", "Launcher", ")", "{", "kern", ".", "Launchers", "=", "append", "(", "kern", ".", "Launchers", ",", "pl", "...", ")", "\n", "}" ]

[ "AddProcesses", "extends", "the", "services", "that", "we", "launch", "at", "boot" ]

[ "func", "(", "kern", "*", "Kernel", ")", "Boot", "(", ")", "(", "err", "error", ")", "{", "for", "_", ",", "launcher", ":=", "range", "kern", ".", "Launchers", "{", "if", "launcher", ".", "Enabled", "{", "srvr", ",", "err", ":=", "launcher", ".", "Launch", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "launcher", ".", "Name", ",", "err", ")", "\n", "}", "\n\n", "kern", ".", "processes", "[", "launcher", ".", "Name", "]", "=", "srvr", "\n", "}", "\n", "}", "\n", "go", "kern", ".", "supervise", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Boot", "the", "kernel", "starting", "Tendermint", "and", "RPC", "layers" ]

[ "func", "(", "kern", "*", "Kernel", ")", "supervise", "(", ")", "{", "// perform disaster restarts of the kernel; rejoining the network as if we were a new node.", "shutdownCh", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "reloadCh", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "syncCh", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "shutdownCh", ",", "syscall", ".", "SIGINT", ",", "syscall", ".", "SIGTERM", ",", "syscall", ".", "SIGKILL", ")", "\n", "signal", ".", "Notify", "(", "reloadCh", ",", "syscall", ".", "SIGHUP", ")", "\n", "signal", ".", "Notify", "(", "syncCh", ",", "syscall", ".", "SIGUSR1", ")", "\n", "for", "{", "select", "{", "case", "<-", "reloadCh", ":", "err", ":=", "kern", ".", "Logger", ".", "Reload", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "kern", ",", "err", ")", "\n", "}", "\n", "case", "<-", "syncCh", ":", "err", ":=", "kern", ".", "Logger", ".", "Sync", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "kern", ",", "err", ")", "\n", "}", "\n", "case", "sig", ":=", "<-", "shutdownCh", ":", "kern", ".", "Logger", ".", "InfoMsg", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sig", ")", ",", "\"", "\"", ",", "sig", ".", "String", "(", ")", ")", "\n", "kern", ".", "ShutdownAndExit", "(", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "Supervise", "kernel", "once", "booted" ]

[ "func", "(", "kern", "*", "Kernel", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "kern", ".", "shutdownOnce", ".", "Do", "(", "func", "(", ")", "{", "logger", ":=", "kern", ".", "Logger", ".", "WithScope", "(", "\"", "\"", ")", "\n", "logger", ".", "InfoMsg", "(", "\"", "\"", ")", "\n", "logger", ".", "InfoMsg", "(", "\"", "\"", ")", "\n", "// Shutdown servers in reverse order to boot", "for", "i", ":=", "len", "(", "kern", ".", "Launchers", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "name", ":=", "kern", ".", "Launchers", "[", "i", "]", ".", "Name", "\n", "proc", ",", "ok", ":=", "kern", ".", "processes", "[", "name", "]", "\n", "if", "ok", "{", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "name", ")", "\n", "sErr", ":=", "proc", ".", "Shutdown", "(", "ctx", ")", "\n", "if", "sErr", "!=", "nil", "{", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "name", ",", "structure", ".", "ErrorKey", ",", "sErr", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "sErr", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "logger", ".", "InfoMsg", "(", "\"", "\"", ")", "\n", "// Best effort", "structure", ".", "Sync", "(", "kern", ".", "Logger", ".", "Info", ")", "\n", "structure", ".", "Sync", "(", "kern", ".", "Logger", ".", "Trace", ")", "\n", "// We don't want to wait for them, but yielding for a cooldown Let other goroutines flush", "// potentially interesting final output (e.g. log messages)", "time", ".", "Sleep", "(", "CooldownTime", ")", "\n", "close", "(", "kern", ".", "shutdownNotify", ")", "\n", "}", ")", "\n", "return", "\n", "}" ]

[ "Shutdown", "stops", "the", "kernel", "allowing", "for", "a", "graceful", "shutdown", "of", "components", "in", "order" ]

[ "func", "registerNameTx", "(", "name", "*", "def", ".", "RegisterName", ",", "do", "*", "def", ".", "DeployArgs", ",", "account", "string", ",", "client", "*", "def", ".", "Client", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "*", "payload", ".", "NameTx", ",", "error", ")", "{", "// Set Defaults", "name", ".", "Source", "=", "useDefault", "(", "name", ".", "Source", ",", "account", ")", "\n", "name", ".", "Fee", "=", "useDefault", "(", "name", ".", "Fee", ",", "do", ".", "DefaultFee", ")", "\n", "name", ".", "Amount", "=", "useDefault", "(", "name", ".", "Amount", ",", "do", ".", "DefaultAmount", ")", "\n\n", "// Formulate tx", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "name", ".", "Name", ",", "\"", "\"", ",", "name", ".", "Data", ",", "\"", "\"", ",", "name", ".", "Amount", ")", "\n\n", "return", "client", ".", "Name", "(", "&", "def", ".", "NameArg", "{", "Input", ":", "name", ".", "Source", ",", "Sequence", ":", "name", ".", "Sequence", ",", "Name", ":", "name", ".", "Name", ",", "Amount", ":", "name", ".", "Amount", ",", "Data", ":", "name", ".", "Data", ",", "Fee", ":", "name", ".", "Fee", ",", "}", ",", "logger", ")", "\n", "}" ]

[ "Runs", "an", "individual", "nametx", "." ]

[ "func", "decodeEvent", "(", "header", "*", "exec", ".", "Header", ",", "log", "*", "exec", ".", "LogEvent", ",", "abiSpec", "*", "abi", ".", "AbiSpec", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "// to prepare decoded data and map to event item name", "data", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "var", "eventID", "abi", ".", "EventID", "\n", "copy", "(", "eventID", "[", ":", "]", ",", "log", ".", "Topics", "[", "0", "]", ".", "Bytes", "(", ")", ")", "\n\n", "evAbi", ",", "ok", ":=", "abiSpec", ".", "EventsById", "[", "eventID", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "eventID", ")", "\n", "}", "\n\n", "// decode header to get context data for each event", "data", "[", "types", ".", "EventNameLabel", "]", "=", "evAbi", ".", "Name", "\n", "data", "[", "types", ".", "BlockHeightLabel", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "header", ".", "GetHeight", "(", ")", ")", "\n", "data", "[", "types", ".", "EventTypeLabel", "]", "=", "header", ".", "GetEventType", "(", ")", ".", "String", "(", ")", "\n", "data", "[", "types", ".", "TxTxHashLabel", "]", "=", "header", ".", "TxHash", ".", "String", "(", ")", "\n\n", "// build expected interface type array to get log event values", "unpackedData", ":=", "abi", ".", "GetPackingTypes", "(", "evAbi", ".", "Inputs", ")", "\n\n", "// unpack event data (topics & data part)", "if", "err", ":=", "abi", ".", "UnpackEvent", "(", "&", "evAbi", ",", "log", ".", "Topics", ",", "log", ".", "Data", ",", "unpackedData", "...", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// for each decoded item value, stores it in given item name", "for", "i", ",", "input", ":=", "range", "evAbi", ".", "Inputs", "{", "switch", "v", ":=", "unpackedData", "[", "i", "]", ".", "(", "type", ")", "{", "case", "*", "crypto", ".", "Address", ":", "data", "[", "input", ".", "Name", "]", "=", "v", ".", "String", "(", ")", "\n", "case", "*", "big", ".", "Int", ":", "data", "[", "input", ".", "Name", "]", "=", "v", ".", "String", "(", ")", "\n", "case", "*", "string", ":", "data", "[", "input", ".", "Name", "]", "=", "*", "v", "\n", "default", ":", "data", "[", "input", ".", "Name", "]", "=", "v", "\n", "}", "\n", "}", "\n\n", "return", "data", ",", "nil", "\n", "}" ]

[ "decodeEvent", "unpacks", "&", "decodes", "event", "data" ]

[ "func", "NewBatchChecker", "(", "backend", "ExecutorState", ",", "params", "Params", ",", "blockchain", "contexts", ".", "Blockchain", ",", "logger", "*", "logging", ".", "Logger", ",", "options", "...", "ExecutionOption", ")", "BatchExecutor", "{", "return", "newExecutor", "(", "\"", "\"", ",", "false", ",", "params", ",", "backend", ",", "blockchain", ",", "nil", ",", "logger", ".", "WithScope", "(", "\"", "\"", ")", ",", "options", "...", ")", "\n", "}" ]

[ "Wraps", "a", "cache", "of", "what", "is", "variously", "known", "as", "the", "check", "cache", "and", "mempool" ]

[ "func", "(", "exe", "*", "executor", ")", "Commit", "(", "header", "*", "abciTypes", ".", "Header", ")", "(", "stateHash", "[", "]", "byte", ",", "err", "error", ")", "{", "// The write lock to the executor is controlled by the caller (e.g. abci.App) so we do not acquire it here to avoid", "// deadlock", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "r", ",", "debug", ".", "Stack", "(", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "// Capture height", "height", ":=", "exe", ".", "block", ".", "Height", "\n", "exe", ".", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "exe", ".", "block", ".", "Height", ")", "\n", "// Form BlockExecution for this block from TxExecutions and Tendermint block header", "blockExecution", ",", "err", ":=", "exe", ".", "finaliseBlockExecution", "(", "header", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// First commit the app state, this app hash will not get checkpointed until the next block when we are sure", "// that nothing in the downstream commit process could have failed. At worst we go back one block.", "hash", ",", "version", ",", "err", ":=", "exe", ".", "state", ".", "Update", "(", "func", "(", "ws", "state", ".", "Updatable", ")", "error", "{", "// flush the caches", "err", ":=", "exe", ".", "stateCache", ".", "Flush", "(", "ws", ",", "exe", ".", "state", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "exe", ".", "nameRegCache", ".", "Flush", "(", "ws", ",", "exe", ".", "state", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "exe", ".", "proposalRegCache", ".", "Flush", "(", "ws", ",", "exe", ".", "state", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "exe", ".", "validatorCache", ".", "Flush", "(", "ws", ",", "exe", ".", "state", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "ws", ".", "AddBlock", "(", "blockExecution", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "expectedHeight", ":=", "HeightAtVersion", "(", "version", ")", "\n", "if", "expectedHeight", "!=", "height", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "version", ",", "expectedHeight", ",", "height", ")", "\n", "}", "\n", "// Now state is fully committed publish events (this should be the last thing we do)", "exe", ".", "publishBlock", "(", "blockExecution", ")", "\n", "return", "hash", ",", "nil", "\n", "}" ]

[ "Commit", "the", "current", "state", "-", "optionally", "pass", "in", "the", "tendermint", "ABCI", "header", "for", "that", "to", "be", "included", "with", "the", "BeginBlock", "StreamEvent" ]

[ "func", "(", "exe", "*", "executor", ")", "updateSignatories", "(", "txEnv", "*", "txs", ".", "Envelope", ")", "error", "{", "for", "_", ",", "sig", ":=", "range", "txEnv", ".", "Signatories", "{", "// pointer dereferences are safe since txEnv.Validate() is run by txEnv.Verify() above which checks they are", "// non-nil", "acc", ",", "err", ":=", "exe", ".", "stateCache", ".", "GetAccount", "(", "*", "sig", ".", "Address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "sig", ".", "Address", ")", "\n", "}", "\n", "// Important that verify has been run against signatories at this point", "if", "sig", ".", "PublicKey", ".", "GetAddress", "(", ")", "!=", "acc", ".", "Address", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "acc", ".", "Address", ",", "sig", ".", "PublicKey", ")", "\n", "}", "\n", "acc", ".", "PublicKey", "=", "*", "sig", ".", "PublicKey", "\n\n", "exe", ".", "logger", ".", "TraceMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "exe", ".", "block", ".", "Height", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "acc", ".", "Address", ",", "\"", "\"", ",", "acc", ".", "Sequence", ",", "\"", "\"", ",", "acc", ".", "Sequence", "+", "1", ")", "\n", "acc", ".", "Sequence", "++", "\n", "err", "=", "exe", ".", "stateCache", ".", "UpdateAccount", "(", "acc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Capture", "public", "keys", "and", "update", "sequence", "numbers" ]

[ "func", "(", "p", "PublicKey", ")", "ABCIPubKey", "(", ")", "abci", ".", "PubKey", "{", "return", "abci", ".", "PubKey", "{", "Type", ":", "p", ".", "CurveType", ".", "ABCIType", "(", ")", ",", "Data", ":", "p", ".", "PublicKey", ",", "}", "\n", "}" ]

[ "PublicKey", "extensions", "Return", "the", "ABCI", "PubKey", ".", "See", "Tendermint", "protobuf", ".", "go", "for", "the", "go", "-", "crypto", "conversion", "this", "is", "based", "on" ]

[ "func", "SpecLoader", "(", "specFileOrDirs", "[", "]", "string", ",", "createBlkTxTables", "bool", ")", "(", "*", "Projection", ",", "error", ")", "{", "var", "projection", "*", "Projection", "\n", "var", "err", "error", "\n\n", "if", "len", "(", "specFileOrDirs", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "projection", ",", "err", "=", "NewProjectionFromFolder", "(", "specFileOrDirs", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "createBlkTxTables", "{", "// add block & tx to tables definition", "blkTxTables", ":=", "getBlockTxTablesDefinition", "(", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "blkTxTables", "{", "projection", ".", "Tables", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "}", "\n\n", "return", "projection", ",", "nil", "\n", "}" ]

[ "SpecLoader", "loads", "spec", "files", "and", "parses", "them" ]

[ "func", "getBlockTxTablesDefinition", "(", ")", "types", ".", "EventTables", "{", "return", "types", ".", "EventTables", "{", "types", ".", "SQLBlockTableName", ":", "&", "types", ".", "SQLTable", "{", "Name", ":", "types", ".", "SQLBlockTableName", ",", "Columns", ":", "[", "]", "*", "types", ".", "SQLTableColumn", "{", "{", "Name", ":", "types", ".", "SQLColumnLabelHeight", ",", "Type", ":", "types", ".", "SQLColumnTypeVarchar", ",", "Length", ":", "100", ",", "Primary", ":", "true", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelBlockHeader", ",", "Type", ":", "types", ".", "SQLColumnTypeJSON", ",", "Primary", ":", "false", ",", "}", ",", "}", ",", "}", ",", "types", ".", "SQLTxTableName", ":", "&", "types", ".", "SQLTable", "{", "Name", ":", "types", ".", "SQLTxTableName", ",", "Columns", ":", "[", "]", "*", "types", ".", "SQLTableColumn", "{", "// transaction table", "{", "Name", ":", "types", ".", "SQLColumnLabelHeight", ",", "Type", ":", "types", ".", "SQLColumnTypeVarchar", ",", "Length", ":", "100", ",", "Primary", ":", "true", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelTxHash", ",", "Type", ":", "types", ".", "SQLColumnTypeVarchar", ",", "Length", ":", "txs", ".", "HashLengthHex", ",", "Primary", ":", "true", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelIndex", ",", "Type", ":", "types", ".", "SQLColumnTypeNumeric", ",", "Length", ":", "0", ",", "Primary", ":", "false", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelTxType", ",", "Type", ":", "types", ".", "SQLColumnTypeVarchar", ",", "Length", ":", "100", ",", "Primary", ":", "false", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelEnvelope", ",", "Type", ":", "types", ".", "SQLColumnTypeJSON", ",", "Primary", ":", "false", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelEvents", ",", "Type", ":", "types", ".", "SQLColumnTypeJSON", ",", "Primary", ":", "false", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelResult", ",", "Type", ":", "types", ".", "SQLColumnTypeJSON", ",", "Primary", ":", "false", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelReceipt", ",", "Type", ":", "types", ".", "SQLColumnTypeJSON", ",", "Primary", ":", "false", ",", "}", ",", "{", "Name", ":", "types", ".", "SQLColumnLabelException", ",", "Type", ":", "types", ".", "SQLColumnTypeJSON", ",", "Primary", ":", "false", ",", "}", ",", "}", ",", "}", ",", "}", "\n", "}" ]

[ "getBlockTxTablesDefinition", "returns", "block", "&", "transaction", "structures" ]

[ "func", "DecodeFunctionReturnFromFile", "(", "abiLocation", ",", "binPath", ",", "funcName", "string", ",", "resultRaw", "[", "]", "byte", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "[", "]", "*", "Variable", ",", "error", ")", "{", "abiSpecBytes", ",", "err", ":=", "readAbi", "(", "binPath", ",", "abiLocation", ",", "logger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "logger", ".", "TraceMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "abiSpecBytes", ")", "\n\n", "// Unpack the result", "return", "DecodeFunctionReturn", "(", "abiSpecBytes", ",", "funcName", ",", "resultRaw", ")", "\n", "}" ]

[ "DecodeFunctionReturnFromFile", "ABI", "decodes", "the", "return", "value", "from", "a", "contract", "function", "call", "." ]

[ "func", "LoadPath", "(", "abiFileOrDirs", "...", "string", ")", "(", "*", "AbiSpec", ",", "error", ")", "{", "if", "len", "(", "abiFileOrDirs", ")", "==", "0", "{", "return", "&", "AbiSpec", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "specs", ":=", "make", "(", "[", "]", "*", "AbiSpec", ",", "0", ")", "\n\n", "for", "_", ",", "dir", ":=", "range", "abiFileOrDirs", "{", "err", ":=", "filepath", ".", "Walk", "(", "dir", ",", "func", "(", "path", "string", ",", "fi", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ",", "err", ")", "\n", "}", "\n", "ext", ":=", "filepath", ".", "Ext", "(", "path", ")", "\n", "if", "fi", ".", "IsDir", "(", ")", "||", "!", "(", "ext", "==", "\"", "\"", "||", "ext", "==", "\"", "\"", ")", "{", "return", "nil", "\n", "}", "\n", "if", "err", "==", "nil", "{", "abiSpc", ",", "err", ":=", "ReadAbiSpecFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", "+", "path", ")", "\n", "}", "\n", "specs", "=", "append", "(", "specs", ",", "abiSpc", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "AbiSpec", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n", "return", "MergeAbiSpec", "(", "specs", ")", ",", "nil", "\n", "}" ]

[ "LoadPath", "loads", "one", "abi", "file", "or", "finds", "all", "files", "in", "a", "directory" ]

[ "func", "(", "nv", "*", "NodeView", ")", "MempoolTransactions", "(", "maxTxs", "int", ")", "(", "[", "]", "*", "txs", ".", "Envelope", ",", "error", ")", "{", "var", "transactions", "[", "]", "*", "txs", ".", "Envelope", "\n", "for", "_", ",", "txBytes", ":=", "range", "nv", ".", "tmNode", ".", "MempoolReactor", "(", ")", ".", "Mempool", ".", "ReapMaxTxs", "(", "maxTxs", ")", "{", "txEnv", ",", "err", ":=", "nv", ".", "txDecoder", ".", "DecodeTx", "(", "txBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "transactions", "=", "append", "(", "transactions", ",", "txEnv", ")", "\n", "}", "\n", "return", "transactions", ",", "nil", "\n", "}" ]

[ "Pass", "-", "1", "to", "get", "all", "available", "transactions" ]

[ "func", "FullAccount", "(", "name", "string", ")", "GenesisSpec", "{", "// Inheriting from the arbitrary figures used by monax tool for now", "amount", ":=", "uint64", "(", "99999999999999", ")", "\n", "Power", ":=", "uint64", "(", "9999999999", ")", "\n", "return", "GenesisSpec", "{", "Accounts", ":", "[", "]", "TemplateAccount", "{", "{", "Name", ":", "name", ",", "Amounts", ":", "balance", ".", "New", "(", ")", ".", "Native", "(", "amount", ")", ".", "Power", "(", "Power", ")", ",", "Permissions", ":", "[", "]", "string", "{", "permission", ".", "AllString", "}", ",", "}", ",", "}", ",", "}", "\n", "}" ]

[ "Files", "here", "can", "be", "used", "as", "starting", "points", "for", "building", "various", "chain", "types", "but", "are", "otherwise", "a", "fairly", "unprincipled", "collection", "of", "GenesisSpecs", "that", "we", "find", "useful", "in", "testing", "and", "development" ]

[ "func", "mergeAccounts", "(", "bases", ",", "overrides", "[", "]", "TemplateAccount", ")", "[", "]", "TemplateAccount", "{", "indexOfBase", ":=", "make", "(", "map", "[", "string", "]", "int", ",", "len", "(", "bases", ")", ")", "\n", "for", "i", ",", "ta", ":=", "range", "bases", "{", "if", "ta", ".", "Name", "!=", "\"", "\"", "{", "indexOfBase", "[", "ta", ".", "Name", "]", "=", "i", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "override", ":=", "range", "overrides", "{", "if", "override", ".", "Name", "!=", "\"", "\"", "{", "if", "i", ",", "ok", ":=", "indexOfBase", "[", "override", ".", "Name", "]", ";", "ok", "{", "bases", "[", "i", "]", "=", "mergeAccount", "(", "bases", "[", "i", "]", ",", "override", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "bases", "=", "append", "(", "bases", ",", "override", ")", "\n", "}", "\n", "return", "bases", "\n", "}" ]

[ "Merge", "accounts", "by", "adding", "to", "base", "list", "or", "updating", "previously", "named", "account" ]

[ "func", "getNameAddr", "(", "keysDir", ",", "name", ",", "addr", "string", ")", "(", "string", ",", "error", ")", "{", "if", "name", "==", "\"", "\"", "&&", "addr", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// name takes precedent if both are given", "var", "err", "error", "\n", "if", "name", "!=", "\"", "\"", "{", "addr", ",", "err", "=", "coreNameGet", "(", "keysDir", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "\n", "return", "strings", ".", "ToUpper", "(", "addr", ")", ",", "nil", "\n", "}" ]

[ "return", "addr", "from", "name", "or", "addr" ]

[ "func", "RunPlaybooks", "(", "args", "*", "def", ".", "DeployArgs", ",", "playbooks", "[", "]", "string", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "int", ",", "error", ")", "{", "// if bin and abi paths are default cli settings then use the", "// stated defaults of do.Path plus bin|abi", "if", "args", ".", "Path", "==", "\"", "\"", "{", "var", "err", "error", "\n", "args", ".", "Path", ",", "err", "=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "}", "\n\n", "// useful for debugging", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "args", ".", "Chain", ",", "\"", "\"", ",", "args", ".", "KeysService", ")", "\n\n", "workQ", ":=", "make", "(", "chan", "playbookWork", ",", "100", ")", "\n", "resultQ", ":=", "make", "(", "chan", "playbookResult", ",", "100", ")", "\n\n", "for", "i", ":=", "1", ";", "i", "<=", "args", ".", "Jobs", ";", "i", "++", "{", "go", "worker", "(", "workQ", ",", "resultQ", ",", "args", ",", "logger", ")", "\n", "}", "\n\n", "for", "i", ",", "playbook", ":=", "range", "playbooks", "{", "workQ", "<-", "playbookWork", "{", "jobNo", ":", "i", ",", "playbook", ":", "playbook", "}", "\n", "}", "\n", "close", "(", "workQ", ")", "\n\n", "// work queued, now read the results", "results", ":=", "make", "(", "[", "]", "*", "playbookResult", ",", "len", "(", "playbooks", ")", ")", "\n", "printed", ":=", "0", "\n", "failures", ":=", "0", "\n", "successes", ":=", "0", "\n\n", "for", "range", "playbooks", "{", "jobResult", ":=", "<-", "resultQ", "\n", "results", "[", "jobResult", ".", "jobNo", "]", "=", "&", "jobResult", "\n", "for", "results", "[", "printed", "]", "!=", "nil", "{", "res", ":=", "results", "[", "printed", "]", "\n", "os", ".", "Stderr", ".", "Write", "(", "res", ".", "log", ".", "Bytes", "(", ")", ")", "\n", "if", "res", ".", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "res", ".", "err", ")", "\n", "}", "\n", "res", ".", "log", ".", "Truncate", "(", "0", ")", "\n", "if", "jobResult", ".", "err", "!=", "nil", "{", "failures", "++", "\n", "}", "else", "{", "successes", "++", "\n", "}", "\n", "printed", "++", "\n", "if", "printed", ">=", "len", "(", "playbooks", ")", "{", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "close", "(", "resultQ", ")", "\n\n", "if", "successes", ">", "0", "{", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "successes", ")", "\n", "for", "i", ",", "playbook", ":=", "range", "playbooks", "{", "res", ":=", "results", "[", "i", "]", "\n", "if", "res", ".", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "i", ",", "\"", "\"", ",", "playbook", ",", "\"", "\"", ",", "res", ".", "duration", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "failures", ">", "0", "{", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "failures", ")", "\n", "for", "i", ",", "playbook", ":=", "range", "playbooks", "{", "res", ":=", "results", "[", "i", "]", "\n", "if", "res", ".", "err", "==", "nil", "{", "continue", "\n", "}", "\n", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "i", ",", "\"", "\"", ",", "playbook", ",", "\"", "\"", ",", "res", ".", "err", ",", "\"", "\"", ",", "res", ".", "duration", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "failures", ",", "nil", "\n", "}" ]

[ "RunPlaybooks", "starts", "workers", "and", "loads", "the", "playbooks", "in", "parallel", "in", "the", "workers", "and", "executes", "them", "." ]

[ "func", "LoadOrNewBlockchain", "(", "db", "dbm", ".", "DB", ",", "genesisDoc", "*", "genesis", ".", "GenesisDoc", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "bool", ",", "*", "Blockchain", ",", "error", ")", "{", "logger", "=", "logger", ".", "WithScope", "(", "\"", "\"", ")", "\n", "logger", ".", "InfoMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "stateKey", ")", "\n", "bc", ",", "err", ":=", "loadBlockchain", "(", "db", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "bc", "!=", "nil", "{", "dbHash", ":=", "bc", ".", "genesisDoc", ".", "Hash", "(", ")", "\n", "argHash", ":=", "genesisDoc", ".", "Hash", "(", ")", "\n", "if", "!", "bytes", ".", "Equal", "(", "dbHash", ",", "argHash", ")", "{", "return", "false", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\\n", "\\n", "\\n", "\\n", "\"", ",", "argHash", ",", "dbHash", ",", "bc", ".", "genesisDoc", ".", "JSONString", "(", ")", ",", "genesisDoc", ".", "JSONString", "(", ")", ")", "\n", "}", "\n", "return", "true", ",", "bc", ",", "nil", "\n", "}", "\n\n", "logger", ".", "InfoMsg", "(", "\"", "\"", ")", "\n", "return", "false", ",", "NewBlockchain", "(", "db", ",", "genesisDoc", ")", ",", "nil", "\n", "}" ]

[ "LoadOrNewBlockchain", "returns", "true", "if", "state", "already", "exists" ]

[ "func", "NewBlockchain", "(", "db", "dbm", ".", "DB", ",", "genesisDoc", "*", "genesis", ".", "GenesisDoc", ")", "*", "Blockchain", "{", "bc", ":=", "&", "Blockchain", "{", "db", ":", "db", ",", "genesisHash", ":", "genesisDoc", ".", "Hash", "(", ")", ",", "genesisDoc", ":", "*", "genesisDoc", ",", "chainID", ":", "genesisDoc", ".", "ChainID", "(", ")", ",", "lastBlockTime", ":", "genesisDoc", ".", "GenesisTime", ",", "appHashAfterLastBlock", ":", "genesisDoc", ".", "Hash", "(", ")", ",", "}", "\n", "return", "bc", "\n", "}" ]

[ "NewBlockchain", "returns", "a", "pointer", "to", "blockchain", "state", "initialised", "from", "genesis" ]

[ "func", "(", "ct", "SQLColumnType", ")", "IsNumeric", "(", ")", "bool", "{", "return", "ct", "==", "SQLColumnTypeInt", "||", "ct", "==", "SQLColumnTypeSerial", "||", "ct", "==", "SQLColumnTypeNumeric", "||", "ct", "==", "SQLColumnTypeBigInt", "\n", "}" ]

[ "IsNumeric", "determines", "if", "an", "sqlColumnType", "is", "numeric" ]

[ "func", "ConvertPermissionsMapAndRolesToAccountPermissions", "(", "permissions", "map", "[", "string", "]", "bool", ",", "roles", "[", "]", "string", ")", "(", "*", "AccountPermissions", ",", "error", ")", "{", "var", "err", "error", "\n", "accountPermissions", ":=", "&", "AccountPermissions", "{", "}", "\n", "accountPermissions", ".", "Base", ",", "err", "=", "convertPermissionsMapStringIntToBasePermissions", "(", "permissions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "accountPermissions", ".", "Roles", "=", "roles", "\n", "return", "accountPermissions", ",", "nil", "\n", "}" ]

[ "ConvertMapStringIntToPermissions", "converts", "a", "map", "of", "string", "-", "bool", "pairs", "and", "a", "slice", "of", "strings", "for", "the", "roles", "to", "an", "AccountPermissions", "type", ".", "If", "the", "value", "in", "the", "permissions", "map", "is", "true", "for", "a", "particular", "permission", "string", "then", "the", "permission", "will", "be", "set", "in", "the", "AccountsPermissions", ".", "For", "all", "unmentioned", "permissions", "the", "ZeroBasePermissions", "is", "defaulted", "to", "." ]

[ "func", "convertPermissionsMapStringIntToBasePermissions", "(", "permissions", "map", "[", "string", "]", "bool", ")", "(", "BasePermissions", ",", "error", ")", "{", "// initialise basePermissions as ZeroBasePermissions", "basePermissions", ":=", "ZeroBasePermissions", "\n\n", "for", "permissionName", ",", "value", ":=", "range", "permissions", "{", "permissionsFlag", ",", "err", ":=", "PermStringToFlag", "(", "permissionName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "basePermissions", ",", "err", "\n", "}", "\n", "// sets the permissions bitflag and the setbit flag for the permission.", "basePermissions", ".", "Set", "(", "permissionsFlag", ",", "value", ")", "\n", "}", "\n\n", "return", "basePermissions", ",", "nil", "\n", "}" ]

[ "convertPermissionsMapStringIntToBasePermissions", "converts", "a", "map", "of", "string", "-", "bool", "pairs", "to", "BasePermissions", "." ]

[ "func", "BasePermissionsFromStringList", "(", "permissions", "[", "]", "string", ")", "(", "BasePermissions", ",", "error", ")", "{", "permFlag", ",", "err", ":=", "PermFlagFromStringList", "(", "permissions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ZeroBasePermissions", ",", "err", "\n", "}", "\n", "return", "BasePermissions", "{", "Perms", ":", "permFlag", ",", "SetBit", ":", "permFlag", ",", "}", ",", "nil", "\n", "}" ]

[ "Builds", "a", "composite", "BasePermission", "by", "creating", "a", "PermFlag", "from", "permissions", "strings", "and", "setting", "them", "all" ]

[ "func", "PermFlagFromStringList", "(", "permissions", "[", "]", "string", ")", "(", "PermFlag", ",", "error", ")", "{", "var", "permFlag", "PermFlag", "\n", "for", "_", ",", "perm", ":=", "range", "permissions", "{", "s", ":=", "strings", ".", "TrimSpace", "(", "perm", ")", "\n", "if", "s", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "flag", ",", "err", ":=", "PermStringToFlag", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "permFlag", ",", "err", "\n", "}", "\n", "permFlag", "|=", "flag", "\n", "}", "\n", "return", "permFlag", ",", "nil", "\n", "}" ]

[ "Builds", "a", "composite", "PermFlag", "by", "mapping", "each", "permission", "string", "in", "permissions", "to", "its", "flag", "and", "composing", "them", "with", "binary", "or" ]

[ "func", "PermFlagToStringList", "(", "permFlag", "PermFlag", ")", "[", "]", "string", "{", "permStrings", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "NumPermissions", ")", "\n", "for", "i", ":=", "uint", "(", "0", ")", ";", "i", "<", "NumPermissions", ";", "i", "++", "{", "permFlag", ":=", "permFlag", "&", "(", "1", "<<", "i", ")", "\n", "if", "permFlag", ">", "0", "{", "permStrings", "=", "append", "(", "permStrings", ",", "permFlag", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "permStrings", "\n", "}" ]

[ "Creates", "a", "list", "of", "individual", "permission", "flag", "strings", "from", "a", "possibly", "composite", "PermFlag", "by", "projecting", "out", "each", "bit", "and", "adding", "its", "permission", "string", "if", "it", "is", "set" ]

[ "func", "NewService", "(", "state", "acmstate", ".", "IterableStatsReader", ",", "nameReg", "names", ".", "IterableReader", ",", "blockchain", "bcm", ".", "BlockchainInfo", ",", "validators", "validator", ".", "History", ",", "nodeView", "*", "tendermint", ".", "NodeView", ",", "logger", "*", "logging", ".", "Logger", ")", "*", "Service", "{", "return", "&", "Service", "{", "state", ":", "state", ",", "nameReg", ":", "nameReg", ",", "blockchain", ":", "blockchain", ",", "validators", ":", "validators", ",", "nodeView", ":", "nodeView", ",", "logger", ":", "logger", ".", "With", "(", "structure", ".", "ComponentKey", ",", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "Service", "provides", "an", "internal", "query", "and", "information", "service", "with", "serialisable", "return", "types", "on", "which", "can", "accomodate", "a", "number", "of", "transport", "front", "ends" ]

[ "func", "(", "s", "*", "Service", ")", "Blocks", "(", "minHeight", ",", "maxHeight", "int64", ")", "(", "*", "ResultBlocks", ",", "error", ")", "{", "if", "s", ".", "nodeView", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "latestHeight", ":=", "int64", "(", "s", ".", "blockchain", ".", "LastBlockHeight", "(", ")", ")", "\n\n", "if", "minHeight", "<", "1", "{", "minHeight", "=", "latestHeight", "\n", "}", "\n", "if", "maxHeight", "==", "0", "||", "latestHeight", "<", "maxHeight", "{", "maxHeight", "=", "latestHeight", "\n", "}", "\n", "if", "maxHeight", ">", "minHeight", "&&", "maxHeight", "-", "minHeight", ">", "MaxBlockLookback", "{", "minHeight", "=", "maxHeight", "-", "MaxBlockLookback", "\n", "}", "\n\n", "var", "blockMetas", "[", "]", "*", "tmTypes", ".", "BlockMeta", "\n", "for", "height", ":=", "minHeight", ";", "height", "<=", "maxHeight", ";", "height", "++", "{", "blockMeta", ":=", "s", ".", "nodeView", ".", "BlockStore", "(", ")", ".", "LoadBlockMeta", "(", "height", ")", "\n", "blockMetas", "=", "append", "(", "blockMetas", ",", "blockMeta", ")", "\n", "}", "\n\n", "return", "&", "ResultBlocks", "{", "LastHeight", ":", "uint64", "(", "latestHeight", ")", ",", "BlockMetas", ":", "blockMetas", ",", "}", ",", "nil", "\n", "}" ]

[ "Returns", "the", "current", "blockchain", "height", "and", "metadata", "for", "a", "range", "of", "blocks", "between", "minHeight", "and", "maxHeight", ".", "Only", "returns", "maxBlockLookback", "block", "metadata", "from", "the", "top", "of", "the", "range", "of", "blocks", ".", "Passing", "0", "for", "maxHeight", "sets", "the", "upper", "height", "of", "the", "range", "to", "the", "current", "blockchain", "height", "." ]

[ "func", "NewDeterministicGenesis", "(", "seed", "int64", ")", "*", "deterministicGenesis", "{", "return", "&", "deterministicGenesis", "{", "random", ":", "rand", ".", "New", "(", "rand", ".", "NewSource", "(", "seed", ")", ")", ",", "}", "\n", "}" ]

[ "Generates", "deterministic", "pseudo", "-", "random", "genesis", "state" ]

[ "func", "(", "ctx", "*", "GovernanceContext", ")", "Execute", "(", "txe", "*", "exec", ".", "TxExecution", ",", "p", "payload", ".", "Payload", ")", "error", "{", "var", "ok", "bool", "\n", "ctx", ".", "txe", "=", "txe", "\n", "ctx", ".", "tx", ",", "ok", "=", "p", ".", "(", "*", "payload", ".", "GovTx", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "txe", ".", "Envelope", ".", "Tx", ".", "Payload", ")", "\n", "}", "\n", "// Nothing down with any incoming funds at this point", "accounts", ",", "_", ",", "err", ":=", "getInputs", "(", "ctx", ".", "StateWriter", ",", "ctx", ".", "tx", ".", "Inputs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// ensure all inputs have root permissions", "err", "=", "allHavePermission", "(", "ctx", ".", "StateWriter", ",", "permission", ".", "Root", ",", "accounts", ",", "ctx", ".", "Logger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "for", "_", ",", "i", ":=", "range", "ctx", ".", "tx", ".", "Inputs", "{", "txe", ".", "Input", "(", "i", ".", "Address", ",", "nil", ")", "\n", "}", "\n\n", "for", "_", ",", "update", ":=", "range", "ctx", ".", "tx", ".", "AccountUpdates", "{", "if", "update", ".", "Address", "==", "nil", "&&", "update", ".", "PublicKey", "==", "nil", "{", "// We do not want to generate a key", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "update", ")", "\n", "}", "\n", "if", "update", ".", "PublicKey", "==", "nil", "{", "update", ".", "PublicKey", ",", "err", "=", "ctx", ".", "MaybeGetPublicKey", "(", "*", "update", ".", "Address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "// Check address", "if", "update", ".", "PublicKey", "!=", "nil", "{", "address", ":=", "update", ".", "PublicKey", ".", "GetAddress", "(", ")", "\n", "if", "update", ".", "Address", "!=", "nil", "&&", "address", "!=", "*", "update", ".", "Address", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "update", ".", "PublicKey", ",", "address", ",", "update", ".", "Address", ")", "\n", "}", "\n", "update", ".", "Address", "=", "&", "address", "\n", "}", "else", "if", "update", ".", "Balances", "(", ")", ".", "HasPower", "(", ")", "{", "// If we are updating power we will need the key", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "account", ",", "err", ":=", "getOrMakeOutput", "(", "ctx", ".", "StateWriter", ",", "accounts", ",", "*", "update", ".", "Address", ",", "ctx", ".", "Logger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "governAccountEvent", ",", "err", ":=", "ctx", ".", "UpdateAccount", "(", "account", ",", "update", ")", "\n", "if", "err", "!=", "nil", "{", "txe", ".", "GovernAccount", "(", "governAccountEvent", ",", "errors", ".", "AsException", "(", "err", ")", ")", "\n", "return", "err", "\n", "}", "\n", "txe", ".", "GovernAccount", "(", "governAccountEvent", ",", "nil", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GovTx", "provides", "a", "set", "of", "TemplateAccounts", "and", "GovernanceContext", "tries", "to", "alter", "the", "chain", "state", "to", "match", "the", "specification", "given" ]

[ "func", "(", "db", "*", "SQLDB", ")", "findTable", "(", "tableName", "string", ")", "(", "bool", ",", "error", ")", "{", "found", ":=", "0", "\n", "safeTable", ":=", "safe", "(", "tableName", ")", "\n", "query", ":=", "db", ".", "DBAdapter", ".", "FindTableQuery", "(", ")", "\n\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ",", "\"", "\"", ",", "safeTable", ")", "\n", "if", "err", ":=", "db", ".", "DB", ".", "QueryRow", "(", "query", ",", "tableName", ")", ".", "Scan", "(", "&", "found", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "found", "==", "0", "{", "db", ".", "Log", ".", "Warn", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "safeTable", ")", "\n", "return", "false", ",", "nil", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "findTable", "checks", "if", "a", "table", "exists", "in", "the", "default", "schema" ]

[ "func", "(", "db", "*", "SQLDB", ")", "getTableDef", "(", "tableName", "string", ")", "(", "*", "types", ".", "SQLTable", ",", "error", ")", "{", "table", ":=", "&", "types", ".", "SQLTable", "{", "Name", ":", "safe", "(", "tableName", ")", ",", "}", "\n", "found", ",", "err", ":=", "db", ".", "findTable", "(", "table", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "!", "found", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "table", ".", "Name", ")", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", "+", "table", ".", "Name", ")", "\n", "}", "\n\n", "query", ":=", "db", ".", "DBAdapter", ".", "TableDefinitionQuery", "(", ")", "\n\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ",", "\"", "\"", ",", "table", ".", "Name", ")", "\n", "rows", ",", "err", ":=", "db", ".", "DB", ".", "Query", "(", "query", ",", "safe", "(", "tableName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "var", "columns", "[", "]", "*", "types", ".", "SQLTableColumn", "\n\n", "for", "rows", ".", "Next", "(", ")", "{", "var", "columnName", "string", "\n", "var", "columnSQLType", "types", ".", "SQLColumnType", "\n", "var", "columnIsPK", "int", "\n", "var", "columnLength", "int", "\n\n", "if", "err", "=", "rows", ".", "Scan", "(", "&", "columnName", ",", "&", "columnSQLType", ",", "&", "columnLength", ",", "&", "columnIsPK", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "_", ",", "err", "=", "db", ".", "DBAdapter", ".", "TypeMapping", "(", "columnSQLType", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "columns", "=", "append", "(", "columns", ",", "&", "types", ".", "SQLTableColumn", "{", "Name", ":", "columnName", ",", "Type", ":", "columnSQLType", ",", "Length", ":", "columnLength", ",", "Primary", ":", "columnIsPK", "==", "1", ",", "}", ")", "\n", "}", "\n\n", "if", "err", "=", "rows", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "table", ".", "Columns", "=", "columns", "\n", "return", "table", ",", "nil", "\n", "}" ]

[ "getTableDef", "returns", "the", "structure", "of", "a", "given", "SQL", "table" ]

[ "func", "(", "db", "*", "SQLDB", ")", "alterTable", "(", "table", "*", "types", ".", "SQLTable", ")", "error", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "table", ".", "Name", ")", "\n\n", "// prepare log query", "logQuery", ":=", "db", ".", "DBAdapter", ".", "InsertLogQuery", "(", ")", "\n\n", "// current table structure", "safeTable", ":=", "safe", "(", "table", ".", "Name", ")", "\n", "currentTable", ",", "err", ":=", "db", ".", "getTableDef", "(", "safeTable", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sqlValues", ",", "_", ":=", "db", ".", "getJSON", "(", "nil", ")", "\n\n", "// for each column in the new table structure", "for", "order", ",", "newColumn", ":=", "range", "table", ".", "Columns", "{", "found", ":=", "false", "\n\n", "// check if exists in the current table structure", "for", "_", ",", "currentColumn", ":=", "range", "currentTable", ".", "Columns", "{", "// if column exists", "if", "currentColumn", ".", "Name", "==", "newColumn", ".", "Name", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "!", "found", "{", "safeCol", ":=", "safe", "(", "newColumn", ".", "Name", ")", "\n", "query", ",", "dictionary", ":=", "db", ".", "DBAdapter", ".", "AlterColumnQuery", "(", "safeTable", ",", "safeCol", ",", "newColumn", ".", "Type", ",", "newColumn", ".", "Length", ",", "order", ")", "\n\n", "//alter column", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "safe", "(", "query", ")", ")", "\n", "_", ",", "err", "=", "db", ".", "DB", ".", "Exec", "(", "safe", "(", "query", ")", ")", "\n\n", "if", "err", "!=", "nil", "{", "if", "db", ".", "DBAdapter", ".", "ErrorEquals", "(", "err", ",", "types", ".", "SQLErrorTypeDuplicatedColumn", ")", "{", "db", ".", "Log", ".", "Warn", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "safeCol", ")", "\n", "}", "else", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "else", "{", "//store dictionary", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "dictionary", ")", "\n", "_", ",", "err", "=", "db", ".", "DB", ".", "Exec", "(", "dictionary", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Marshal the table into a JSON string.", "var", "jsonData", "[", "]", "byte", "\n", "jsonData", ",", "err", "=", "db", ".", "getJSON", "(", "newColumn", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "newColumn", ")", ")", "\n", "return", "err", "\n", "}", "\n", "//insert log", "_", ",", "err", "=", "db", ".", "DB", ".", "Exec", "(", "logQuery", ",", "table", ".", "Name", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", "types", ".", "ActionAlterTable", ",", "jsonData", ",", "query", ",", "sqlValues", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Ensure triggers are defined", "err", "=", "db", ".", "createTableTriggers", "(", "table", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "table", ")", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "alterTable", "alters", "the", "structure", "of", "a", "SQL", "table", "&", "add", "info", "to", "the", "dictionary" ]

[ "func", "(", "db", "*", "SQLDB", ")", "createTable", "(", "table", "*", "types", ".", "SQLTable", ",", "isInitialise", "bool", ")", "error", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "table", ".", "Name", ")", "\n\n", "// prepare log query", "logQuery", ":=", "db", ".", "DBAdapter", ".", "InsertLogQuery", "(", ")", "\n\n", "//get create table query", "safeTable", ":=", "safe", "(", "table", ".", "Name", ")", "\n", "query", ",", "dictionary", ":=", "db", ".", "DBAdapter", ".", "CreateTableQuery", "(", "safeTable", ",", "table", ".", "Columns", ")", "\n", "if", "query", "==", "\"", "\"", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// create table", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ")", "\n", "_", ",", "err", ":=", "db", ".", "DB", ".", "Exec", "(", "query", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "//store dictionary", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "dictionary", ")", "\n", "_", ",", "err", "=", "db", ".", "DB", ".", "Exec", "(", "dictionary", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "err", "=", "db", ".", "createTableTriggers", "(", "table", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "table", ")", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "//insert log (if action is not database initialization)", "if", "!", "isInitialise", "{", "// Marshal the table into a JSON string.", "var", "jsonData", "[", "]", "byte", "\n", "jsonData", ",", "err", "=", "db", ".", "getJSON", "(", "table", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "table", ")", ")", "\n", "return", "err", "\n", "}", "\n", "sqlValues", ",", "_", ":=", "db", ".", "getJSON", "(", "nil", ")", "\n\n", "//insert log", "_", ",", "err", "=", "db", ".", "DB", ".", "Exec", "(", "logQuery", ",", "table", ".", "Name", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", "types", ".", "ActionCreateTable", ",", "jsonData", ",", "query", ",", "sqlValues", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "createTable", "creates", "a", "new", "table" ]

[ "func", "(", "db", "*", "SQLDB", ")", "getSelectQuery", "(", "table", "*", "types", ".", "SQLTable", ",", "height", "uint64", ")", "(", "string", ",", "error", ")", "{", "fields", ":=", "\"", "\"", "\n\n", "for", "_", ",", "tableColumn", ":=", "range", "table", ".", "Columns", "{", "if", "fields", "!=", "\"", "\"", "{", "fields", "+=", "\"", "\"", "\n", "}", "\n", "fields", "+=", "db", ".", "DBAdapter", ".", "SecureName", "(", "tableColumn", ".", "Name", ")", "\n", "}", "\n\n", "if", "fields", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "query", ":=", "db", ".", "DBAdapter", ".", "SelectRowQuery", "(", "table", ".", "Name", ",", "fields", ",", "strconv", ".", "FormatUint", "(", "height", ",", "10", ")", ")", "\n", "return", "query", ",", "nil", "\n", "}" ]

[ "getSelectQuery", "builds", "a", "select", "query", "for", "a", "specific", "SQL", "table", "and", "a", "given", "block" ]

[ "func", "(", "db", "*", "SQLDB", ")", "getBlockTables", "(", "height", "uint64", ")", "(", "types", ".", "EventTables", ",", "error", ")", "{", "tables", ":=", "make", "(", "types", ".", "EventTables", ")", "\n\n", "query", ":=", "db", ".", "DBAdapter", ".", "SelectLogQuery", "(", ")", "\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ",", "\"", "\"", ",", "height", ")", "\n\n", "rows", ",", "err", ":=", "db", ".", "DB", ".", "Query", "(", "query", ",", "height", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "tables", ",", "err", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "for", "rows", ".", "Next", "(", ")", "{", "var", "eventName", ",", "tableName", "string", "\n", "var", "table", "*", "types", ".", "SQLTable", "\n\n", "err", "=", "rows", ".", "Scan", "(", "&", "tableName", ",", "&", "eventName", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "tables", ",", "err", "\n", "}", "\n\n", "err", "=", "rows", ".", "Err", "(", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "tables", ",", "err", "\n", "}", "\n\n", "table", ",", "err", "=", "db", ".", "getTableDef", "(", "tableName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tables", ",", "err", "\n", "}", "\n\n", "tables", "[", "tableName", "]", "=", "table", "\n", "}", "\n\n", "return", "tables", ",", "nil", "\n", "}" ]

[ "getBlockTables", "return", "all", "SQL", "tables", "that", "have", "been", "involved", "in", "a", "given", "batch", "transaction", "for", "a", "specific", "block" ]

[ "func", "safe", "(", "parameter", "string", ")", "string", "{", "replacer", ":=", "strings", ".", "NewReplacer", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "replacer", ".", "Replace", "(", "parameter", ")", "\n", "}" ]

[ "safe", "sanitizes", "a", "parameter" ]

[ "func", "(", "db", "*", "SQLDB", ")", "getJSON", "(", "JSON", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "JSON", "!=", "nil", "{", "return", "json", ".", "Marshal", "(", "JSON", ")", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "\"", "\"", ")", "\n", "}" ]

[ "getJSON", "returns", "marshaled", "json", "from", "JSON", "single", "column" ]

[ "func", "(", "db", "*", "SQLDB", ")", "getJSONFromValues", "(", "values", "[", "]", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "values", "!=", "nil", "{", "return", "json", ".", "Marshal", "(", "values", ")", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "\"", "\"", ")", "\n", "}" ]

[ "getJSONFromValues", "returns", "marshaled", "json", "from", "query", "values" ]

[ "func", "(", "db", "*", "SQLDB", ")", "getValuesFromJSON", "(", "JSON", "string", ")", "(", "[", "]", "interface", "{", "}", ",", "error", ")", "{", "pointers", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ")", "\n", "bytes", ":=", "[", "]", "byte", "(", "JSON", ")", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "bytes", ",", "&", "pointers", ")", "\n", "return", "pointers", ",", "err", "\n", "}" ]

[ "getValuesFromJSON", "returns", "query", "values", "from", "unmarshaled", "JSON", "column" ]

[ "func", "AsException", "(", "err", "error", ")", "*", "Exception", "{", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "switch", "e", ":=", "err", ".", "(", "type", ")", "{", "case", "*", "Exception", ":", "return", "e", "\n", "case", "CodedError", ":", "return", "NewException", "(", "e", ".", "ErrorCode", "(", ")", ",", "e", ".", "String", "(", ")", ")", "\n", "default", ":", "return", "NewException", "(", "ErrorCodeGeneric", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "Wraps", "any", "error", "as", "a", "Exception" ]

[ "func", "PublicKeyFromBytes", "(", "bs", "[", "]", "byte", ",", "curveType", "CurveType", ")", "(", "PublicKey", ",", "error", ")", "{", "switch", "curveType", "{", "case", "CurveTypeEd25519", ":", "if", "len", "(", "bs", ")", "!=", "ed25519", ".", "PublicKeySize", "{", "return", "PublicKey", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "bs", ")", ",", "ed25519", ".", "PublicKeySize", ")", "\n", "}", "\n", "case", "CurveTypeSecp256k1", ":", "if", "len", "(", "bs", ")", "!=", "btcec", ".", "PubKeyBytesLenCompressed", "{", "return", "PublicKey", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "bs", ")", ",", "btcec", ".", "PubKeyBytesLenCompressed", ")", "\n", "}", "\n", "case", "CurveTypeUnset", ":", "if", "len", "(", "bs", ")", ">", "0", "{", "return", "PublicKey", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "bs", ")", "\n", "}", "\n", "return", "PublicKey", "{", "}", ",", "nil", "\n", "default", ":", "return", "PublicKey", "{", "}", ",", "ErrInvalidCurve", "(", "curveType", ")", "\n", "}", "\n\n", "return", "PublicKey", "{", "PublicKey", ":", "bs", ",", "CurveType", ":", "curveType", "}", ",", "nil", "\n", "}" ]

[ "Currently", "this", "is", "a", "stub", "that", "reads", "the", "raw", "bytes", "returned", "by", "key_client", "and", "returns", "an", "ed25519", "public", "key", "." ]

[ "func", "(", "p", "*", "PrivateKey", ")", "Reinitialise", "(", ")", "error", "{", "initP", ",", "err", ":=", "PrivateKeyFromRawBytes", "(", "p", ".", "RawBytes", "(", ")", ",", "p", ".", "CurveType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "*", "p", "=", "initP", "\n", "return", "nil", "\n", "}" ]

[ "Reinitialise", "after", "serialisation" ]

[ "func", "EnsureEd25519PrivateKeyCorrect", "(", "candidatePrivateKey", "ed25519", ".", "PrivateKey", ")", "error", "{", "if", "len", "(", "candidatePrivateKey", ")", "!=", "ed25519", ".", "PrivateKeySize", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ed25519", ".", "PrivateKeySize", ",", "len", "(", "candidatePrivateKey", ")", ")", "\n", "}", "\n", "_", ",", "derivedPrivateKey", ",", "err", ":=", "ed25519", ".", "GenerateKey", "(", "bytes", ".", "NewBuffer", "(", "candidatePrivateKey", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "bytes", ".", "Equal", "(", "derivedPrivateKey", ",", "candidatePrivateKey", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "candidatePrivateKey", ",", "candidatePrivateKey", ",", "derivedPrivateKey", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Ensures", "the", "last", "32", "bytes", "of", "the", "ed25519", "private", "key", "is", "the", "public", "key", "derived", "from", "the", "first", "32", "private", "bytes" ]

[ "func", "(", "cas", "*", "ContentAddressedStore", ")", "Put", "(", "data", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "hasher", ":=", "sha256", ".", "New", "(", ")", "\n", "_", ",", "err", ":=", "hasher", ".", "Write", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "hash", ":=", "hasher", ".", "Sum", "(", "nil", ")", "\n", "cas", ".", "db", ".", "SetSync", "(", "hash", ",", "data", ")", "\n", "return", "hash", ",", "nil", "\n", "}" ]

[ "These", "function", "match", "those", "used", "in", "Hoard", "Put", "data", "in", "the", "database", "by", "saving", "data", "with", "a", "key", "that", "is", "its", "sha256", "hash" ]

[ "func", "push", "(", "stack", "[", "]", "*", "logconfig", ".", "SinkConfig", ",", "sinkConfigs", "...", "*", "logconfig", ".", "SinkConfig", ")", "[", "]", "*", "logconfig", ".", "SinkConfig", "{", "for", "_", ",", "sinkConfig", ":=", "range", "sinkConfigs", "{", "peek", "(", "stack", ")", ".", "AddSinks", "(", "sinkConfig", ")", "\n", "stack", "=", "append", "(", "stack", ",", "sinkConfig", ")", "\n", "}", "\n", "return", "stack", "\n", "}" ]

[ "Push", "a", "path", "sequence", "of", "sinks", "onto", "the", "stack" ]

[ "func", "NewConsumer", "(", "cfg", "*", "config", ".", "VentConfig", ",", "log", "*", "logger", ".", "Logger", ",", "eventChannel", "chan", "types", ".", "EventData", ")", "*", "Consumer", "{", "return", "&", "Consumer", "{", "Config", ":", "cfg", ",", "Log", ":", "log", ",", "Closing", ":", "false", ",", "EventsChannel", ":", "eventChannel", ",", "}", "\n", "}" ]

[ "NewConsumer", "constructs", "a", "new", "consumer", "configuration", ".", "The", "event", "channel", "will", "be", "passed", "a", "collection", "of", "rows", "generated", "from", "all", "of", "the", "events", "in", "a", "single", "block", "It", "will", "be", "closed", "by", "the", "consumer", "when", "it", "is", "finished" ]