Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "c", "*", "Consumer", ")", "Health", "(", ")", "error", "{", "if", "c", ".", "Closing", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// check db status", "if", "c", ".", "DB", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "DB", ".", "Ping", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// check grpc connection status", "if", "c", ".", "GRPCConnection", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "grpcState", ":=", "c", ".", "GRPCConnection", ".", "GetState", "(", ")", ";", "grpcState", "!=", "connectivity", ".", "Ready", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Health", "returns", "the", "health", "status", "for", "the", "consumer" ]

[ "func", "(", "c", "*", "Consumer", ")", "Shutdown", "(", ")", "{", "c", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "Closing", "=", "true", "\n", "c", ".", "GRPCConnection", ".", "Close", "(", ")", "\n", "}" ]

[ "Shutdown", "gracefully", "shuts", "down", "the", "events", "consumer" ]

[ "func", "NewBlockData", "(", "height", "uint64", ")", "*", "BlockData", "{", "data", ":=", "types", ".", "EventData", "{", "Tables", ":", "make", "(", "map", "[", "string", "]", "types", ".", "EventDataTable", ")", ",", "BlockHeight", ":", "height", ",", "}", "\n\n", "return", "&", "BlockData", "{", "Data", ":", "data", ",", "}", "\n", "}" ]

[ "NewBlockData", "returns", "a", "pointer", "to", "an", "empty", "BlockData", "structure" ]

[ "func", "(", "b", "*", "BlockData", ")", "AddRow", "(", "tableName", "string", ",", "row", "types", ".", "EventDataRow", ")", "{", "if", "_", ",", "ok", ":=", "b", ".", "Data", ".", "Tables", "[", "tableName", "]", ";", "!", "ok", "{", "b", ".", "Data", ".", "Tables", "[", "tableName", "]", "=", "types", ".", "EventDataTable", "{", "}", "\n", "}", "\n", "b", ".", "Data", ".", "Tables", "[", "tableName", "]", "=", "append", "(", "b", ".", "Data", ".", "Tables", "[", "tableName", "]", ",", "row", ")", "\n", "}" ]

[ "AddRow", "appends", "a", "row", "to", "a", "specific", "table", "name", "in", "structure" ]

[ "func", "(", "b", "*", "BlockData", ")", "GetRows", "(", "tableName", "string", ")", "(", "types", ".", "EventDataTable", ",", "error", ")", "{", "if", "table", ",", "ok", ":=", "b", ".", "Data", ".", "Tables", "[", "tableName", "]", ";", "ok", "{", "return", "table", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tableName", ")", "\n", "}" ]

[ "GetRows", "gets", "data", "rows", "for", "a", "given", "table", "name", "from", "structure" ]

[ "func", "(", "b", "*", "BlockData", ")", "PendingRows", "(", "height", "uint64", ")", "bool", "{", "hasRows", ":=", "false", "\n", "// TODO: understand why the guard on height is needed - what does it prevent?", "if", "b", ".", "Data", ".", "BlockHeight", "==", "height", "&&", "len", "(", "b", ".", "Data", ".", "Tables", ")", ">", "0", "{", "hasRows", "=", "true", "\n", "}", "\n", "return", "hasRows", "\n", "}" ]

[ "PendingRows", "returns", "true", "if", "the", "given", "block", "has", "at", "least", "one", "pending", "row", "to", "upsert" ]

[ "func", "NewDynamicMemory", "(", "initialCapacity", ",", "maximumCapacity", "uint64", ",", "errSink", "errors", ".", "Sink", ")", "Memory", "{", "return", "&", "dynamicMemory", "{", "slice", ":", "make", "(", "[", "]", "byte", ",", "initialCapacity", ")", ",", "maximumCapacity", ":", "maximumCapacity", ",", "errSink", ":", "errSink", ",", "}", "\n", "}" ]

[ "Get", "a", "new", "DynamicMemory", "(", "note", "that", "although", "we", "take", "a", "maximumCapacity", "of", "uint64", "we", "currently", "limit", "the", "maximum", "to", "int32", "at", "runtime", "because", "we", "are", "using", "a", "single", "slice", "which", "we", "cannot", "guarantee", "to", "be", "indexable", "above", "int32", "or", "all", "validators" ]

[ "func", "CallSim", "(", "reader", "acmstate", ".", "Reader", ",", "tip", "bcm", ".", "BlockchainInfo", ",", "fromAddress", ",", "address", "crypto", ".", "Address", ",", "data", "[", "]", "byte", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "*", "exec", ".", "TxExecution", ",", "error", ")", "{", "cache", ":=", "acmstate", ".", "NewCache", "(", "reader", ")", "\n", "exe", ":=", "contexts", ".", "CallContext", "{", "RunCall", ":", "true", ",", "StateWriter", ":", "cache", ",", "Blockchain", ":", "tip", ",", "Logger", ":", "logger", ",", "}", "\n\n", "txe", ":=", "exec", ".", "NewTxExecution", "(", "txs", ".", "Enclose", "(", "tip", ".", "ChainID", "(", ")", ",", "&", "payload", ".", "CallTx", "{", "Input", ":", "&", "payload", ".", "TxInput", "{", "Address", ":", "fromAddress", ",", "}", ",", "Address", ":", "&", "address", ",", "Data", ":", "data", ",", "GasLimit", ":", "contexts", ".", "GasLimit", ",", "}", ")", ")", "\n", "err", ":=", "exe", ".", "Execute", "(", "txe", ",", "txe", ".", "Envelope", ".", "Tx", ".", "Payload", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "txe", ",", "nil", "\n", "}" ]

[ "Run", "a", "contract", "s", "code", "on", "an", "isolated", "and", "unpersisted", "state", "Cannot", "be", "used", "to", "create", "new", "contracts" ]

[ "func", "CallCodeSim", "(", "reader", "acmstate", ".", "Reader", ",", "tip", "bcm", ".", "BlockchainInfo", ",", "fromAddress", ",", "address", "crypto", ".", "Address", ",", "code", ",", "data", "[", "]", "byte", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "*", "exec", ".", "TxExecution", ",", "error", ")", "{", "// Attach code to target account (overwriting target)", "cache", ":=", "acmstate", ".", "NewCache", "(", "reader", ")", "\n", "err", ":=", "cache", ".", "UpdateAccount", "(", "&", "acm", ".", "Account", "{", "Address", ":", "address", ",", "Code", ":", "code", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "CallSim", "(", "cache", ",", "tip", ",", "fromAddress", ",", "address", ",", "data", ",", "logger", ")", "\n", "}" ]

[ "Run", "the", "given", "code", "on", "an", "isolated", "and", "unpersisted", "state", "Cannot", "be", "used", "to", "create", "new", "contracts", "." ]

[ "func", "(", "kern", "*", "Kernel", ")", "LoadKeysFromConfig", "(", "conf", "*", "keys", ".", "KeysConfig", ")", "(", "err", "error", ")", "{", "kern", ".", "keyStore", "=", "keys", ".", "NewKeyStore", "(", "conf", ".", "KeysDirectory", ",", "conf", ".", "AllowBadFilePermissions", ")", "\n", "if", "conf", ".", "RemoteAddress", "!=", "\"", "\"", "{", "kern", ".", "keyClient", ",", "err", "=", "keys", ".", "NewRemoteKeyClient", "(", "conf", ".", "RemoteAddress", ",", "kern", ".", "Logger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "kern", ".", "keyClient", "=", "keys", ".", "NewLocalKeyClient", "(", "kern", ".", "keyStore", ",", "kern", ".", "Logger", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "LoadKeysFromConfig", "sets", "the", "keyClient", "&", "keyStore", "based", "on", "the", "given", "config" ]

[ "func", "(", "kern", "*", "Kernel", ")", "LoadLoggerFromConfig", "(", "conf", "*", "logconfig", ".", "LoggingConfig", ")", "error", "{", "logger", ",", "err", ":=", "lifecycle", ".", "NewLoggerFromLoggingConfig", "(", "conf", ")", "\n", "kern", ".", "SetLogger", "(", "logger", ")", "\n", "return", "err", "\n", "}" ]

[ "LoadLoggerFromConfig", "adds", "a", "logging", "configuration", "to", "the", "kernel" ]

[ "func", "(", "kern", "*", "Kernel", ")", "LoadExecutionOptionsFromConfig", "(", "conf", "*", "execution", ".", "ExecutionConfig", ")", "error", "{", "if", "conf", "!=", "nil", "{", "exeOptions", ",", "err", ":=", "conf", ".", "ExecutionOptions", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "kern", ".", "exeOptions", "=", "exeOptions", "\n", "kern", ".", "timeoutFactor", "=", "conf", ".", "TimeoutFactor", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "LoadExecutionOptionsFromConfig", "builds", "the", "execution", "options", "for", "the", "kernel" ]

[ "func", "(", "kern", "*", "Kernel", ")", "LoadTendermintFromConfig", "(", "conf", "*", "config", ".", "BurrowConfig", ",", "privVal", "tmTypes", ".", "PrivValidator", ")", "(", "err", "error", ")", "{", "if", "conf", ".", "Tendermint", "==", "nil", "||", "!", "conf", ".", "Tendermint", ".", "Enabled", "{", "return", "nil", "\n", "}", "\n\n", "authorizedPeersProvider", ":=", "conf", ".", "Tendermint", ".", "DefaultAuthorizedPeersProvider", "(", ")", "\n", "kern", ".", "database", ".", "Stats", "(", ")", "\n\n", "kern", ".", "info", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "project", ".", "History", ".", "CurrentVersion", "(", ")", ".", "String", "(", ")", ",", "kern", ".", "Blockchain", ".", "ChainID", "(", ")", ",", "privVal", ".", "GetPubKey", "(", ")", ".", "Address", "(", ")", ")", "\n\n", "app", ":=", "abci", ".", "NewApp", "(", "kern", ".", "info", ",", "kern", ".", "Blockchain", ",", "kern", ".", "State", ",", "kern", ".", "checker", ",", "kern", ".", "committer", ",", "kern", ".", "txCodec", ",", "authorizedPeersProvider", ",", "kern", ".", "Panic", ",", "kern", ".", "Logger", ")", "\n\n", "// We could use this to provide/register our own metrics (though this will register them with us). Unfortunately", "// Tendermint currently ignores the metrics passed unless its own server is turned on.", "metricsProvider", ":=", "node", ".", "DefaultMetricsProvider", "(", "&", "tmConfig", ".", "InstrumentationConfig", "{", "Prometheus", ":", "false", ",", "PrometheusListenAddr", ":", "\"", "\"", ",", "}", ")", "\n\n", "genesisDoc", ":=", "kern", ".", "Blockchain", ".", "GenesisDoc", "(", ")", "\n\n", "// find node key", "var", "nodeKey", "*", "crypto", ".", "PrivateKey", "\n", "for", "_", ",", "v", ":=", "range", "genesisDoc", ".", "Validators", "{", "thisAddress", ",", "err", ":=", "crypto", ".", "AddressFromHexString", "(", "privVal", ".", "GetPubKey", "(", ")", ".", "Address", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "if", "v", ".", "Address", "==", "thisAddress", "&&", "v", ".", "NodeAddress", "!=", "nil", "{", "k", ",", "err", ":=", "kern", ".", "keyStore", ".", "GetKey", "(", "\"", "\"", ",", "v", ".", "NodeAddress", ".", "Bytes", "(", ")", ")", "\n", "if", "err", "==", "nil", "{", "nodeKey", "=", "&", "k", ".", "PrivateKey", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n\n", "tmGenesisDoc", ":=", "tendermint", ".", "DeriveGenesisDoc", "(", "&", "genesisDoc", ",", "kern", ".", "Blockchain", ".", "AppHashAfterLastBlock", "(", ")", ")", "\n", "heightValuer", ":=", "log", ".", "Valuer", "(", "func", "(", ")", "interface", "{", "}", "{", "return", "kern", ".", "Blockchain", ".", "LastBlockHeight", "(", ")", "}", ")", "\n", "tmLogger", ":=", "kern", ".", "Logger", ".", "With", "(", "structure", ".", "CallerKey", ",", "log", ".", "Caller", "(", "LoggingCallerDepth", "+", "1", ")", ")", ".", "With", "(", "\"", "\"", ",", "heightValuer", ")", "\n", "kern", ".", "Node", ",", "err", "=", "tendermint", ".", "NewNode", "(", "conf", ".", "TendermintConfig", "(", ")", ",", "privVal", ",", "tmGenesisDoc", ",", "app", ",", "metricsProvider", ",", "nodeKey", ",", "tmLogger", ")", "\n", "return", "err", "\n", "}" ]

[ "LoadTendermintFromConfig", "loads", "our", "consensus", "engine", "into", "the", "kernel" ]

[ "func", "LoadKernelFromConfig", "(", "conf", "*", "config", ".", "BurrowConfig", ")", "(", "*", "Kernel", ",", "error", ")", "{", "kern", ",", "err", ":=", "NewKernel", "(", "conf", ".", "BurrowDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "kern", ".", "LoadLoggerFromConfig", "(", "conf", ".", "Logging", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "kern", ".", "LoadKeysFromConfig", "(", "conf", ".", "Keys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "kern", ".", "LoadExecutionOptionsFromConfig", "(", "conf", ".", "Execution", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "kern", ".", "LoadState", "(", "conf", ".", "GenesisDoc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "conf", ".", "ValidatorAddress", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "privVal", ",", "err", ":=", "kern", ".", "PrivValidator", "(", "*", "conf", ".", "ValidatorAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "kern", ".", "LoadTendermintFromConfig", "(", "conf", ",", "privVal", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "kern", ".", "AddProcesses", "(", "DefaultProcessLaunchers", "(", "kern", ",", "conf", ".", "RPC", ",", "conf", ".", "Keys", ")", "...", ")", "\n", "return", "kern", ",", "nil", "\n", "}" ]

[ "LoadKernelFromConfig", "builds", "and", "returns", "a", "Kernel", "based", "solely", "on", "the", "supplied", "configuration" ]

[ "func", "U256", "(", "x", "*", "big", ".", "Int", ")", "*", "big", ".", "Int", "{", "// Note that the And operation induces big.Int to hold a positive representation of a negative number", "return", "new", "(", "big", ".", "Int", ")", ".", "And", "(", "x", ",", "tt256m1", ")", "\n", "}" ]

[ "Converts", "a", "possibly", "negative", "big", "int", "x", "into", "a", "positive", "big", "int", "encoding", "a", "twos", "complement", "representation", "of", "x", "truncated", "to", "32", "bytes" ]

[ "func", "SignExtend", "(", "back", "uint64", ",", "x", "*", "big", ".", "Int", ")", "*", "big", ".", "Int", "{", "// we assume x contains a signed integer of back + 1 bytes width", "// most significant bit of the back'th byte,", "signBit", ":=", "back", "*", "8", "+", "7", "\n", "// single bit set at sign bit position", "mask", ":=", "new", "(", "big", ".", "Int", ")", ".", "Lsh", "(", "big1", ",", "uint", "(", "signBit", ")", ")", "\n", "// all bits below sign bit set to 1 all above (including sign bit) set to 0", "mask", ".", "Sub", "(", "mask", ",", "big1", ")", "\n", "if", "x", ".", "Bit", "(", "int", "(", "signBit", ")", ")", "==", "1", "{", "// Number represented is negative - set all bits above sign bit (including sign bit)", "return", "x", ".", "Or", "(", "x", ",", "mask", ".", "Not", "(", "mask", ")", ")", "\n", "}", "else", "{", "// Number represented is positive - clear all bits above sign bit (including sign bit)", "return", "x", ".", "And", "(", "x", ",", "mask", ")", "\n", "}", "\n", "}" ]

[ "Treats", "the", "positive", "big", "int", "x", "as", "if", "it", "contains", "an", "embedded", "a", "back", "+", "1", "byte", "signed", "integer", "in", "its", "least", "significant", "bits", "and", "extends", "that", "sign" ]

[ "func", "(", "l", "*", "remoteKeyClient", ")", "HealthCheck", "(", ")", "error", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "context", ".", "Background", "(", ")", ",", "10", "*", "time", ".", "Second", ")", "\n", "defer", "cancel", "(", ")", "\n", "_", ",", "err", ":=", "l", ".", "kc", ".", "List", "(", "ctx", ",", "&", "ListRequest", "{", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "HealthCheck", "returns", "nil", "if", "the", "keys", "instance", "is", "healthy", "error", "otherwise" ]

[ "func", "NewRemoteKeyClient", "(", "rpcAddress", "string", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "KeyClient", ",", "error", ")", "{", "logger", "=", "logger", ".", "WithScope", "(", "\"", "\"", ")", "\n", "var", "opts", "[", "]", "grpc", ".", "DialOption", "\n", "opts", "=", "append", "(", "opts", ",", "grpc", ".", "WithInsecure", "(", ")", ")", "\n", "conn", ",", "err", ":=", "grpc", ".", "Dial", "(", "rpcAddress", ",", "opts", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "kc", ":=", "NewKeysClient", "(", "conn", ")", "\n\n", "return", "&", "remoteKeyClient", "{", "kc", ":", "kc", ",", "rpcAddress", ":", "rpcAddress", ",", "logger", ":", "logger", "}", ",", "nil", "\n", "}" ]

[ "NewRemoteKeyClient", "returns", "a", "new", "keys", "client", "for", "provided", "rpc", "location" ]

[ "func", "NewLocalKeyClient", "(", "ks", "*", "KeyStore", ",", "logger", "*", "logging", ".", "Logger", ")", "KeyClient", "{", "logger", "=", "logger", ".", "WithScope", "(", "\"", "\"", ")", "\n", "return", "&", "localKeyClient", "{", "ks", ":", "ks", ",", "logger", ":", "logger", "}", "\n", "}" ]

[ "NewLocalKeyClient", "returns", "a", "new", "keys", "client", "backed", "by", "the", "local", "filesystem" ]

[ "func", "AddressableSigner", "(", "keyClient", "KeyClient", ",", "address", "crypto", ".", "Address", ")", "(", "*", "Signer", ",", "error", ")", "{", "publicKey", ",", "err", ":=", "keyClient", ".", "PublicKey", "(", "address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// TODO: we can do better than this and return a typed signature when we reform the keys service", "return", "&", "Signer", "{", "keyClient", ":", "keyClient", ",", "address", ":", "address", ",", "publicKey", ":", "publicKey", ",", "}", ",", "nil", "\n", "}" ]

[ "AddressableSigner", "creates", "a", "signer", "that", "assumes", "the", "address", "holds", "an", "Ed25519", "key" ]

[ "func", "(", "adapter", "*", "SQLiteAdapter", ")", "Open", "(", "dbURL", "string", ")", "(", "*", "sql", ".", "DB", ",", "error", ")", "{", "db", ",", "err", ":=", "sql", ".", "Open", "(", "\"", "\"", ",", "dbURL", ")", "\n", "if", "err", "!=", "nil", "{", "adapter", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "db", ",", "nil", "\n", "}" ]

[ "Open", "connects", "to", "a", "SQLiteQL", "database", "opens", "it", "&", "create", "default", "schema", "if", "provided" ]

[ "func", "(", "adapter", "*", "SQLiteAdapter", ")", "AlterColumnQuery", "(", "tableName", ",", "columnName", "string", ",", "sqlColumnType", "types", ".", "SQLColumnType", ",", "length", ",", "order", "int", ")", "(", "string", ",", "string", ")", "{", "sqlType", ",", "_", ":=", "adapter", ".", "TypeMapping", "(", "sqlColumnType", ")", "\n", "if", "length", ">", "0", "{", "sqlType", "=", "Cleanf", "(", "\"", "\"", ",", "sqlType", ",", "length", ")", "\n", "}", "\n\n", "query", ":=", "Cleanf", "(", "\"", "\"", ",", "adapter", ".", "SecureName", "(", "tableName", ")", ",", "adapter", ".", "SecureName", "(", "columnName", ")", ",", "sqlType", ")", "\n\n", "dictionaryQuery", ":=", "Cleanf", "(", "`\n\t\tINSERT INTO %s (%s,%s,%s,%s,%s,%s)\n\t\tVALUES ('%s','%s',%d,%d,%d,%d);`", ",", "types", ".", "SQLDictionaryTableName", ",", "types", ".", "SQLColumnLabelTableName", ",", "types", ".", "SQLColumnLabelColumnName", ",", "types", ".", "SQLColumnLabelColumnType", ",", "types", ".", "SQLColumnLabelColumnLength", ",", "types", ".", "SQLColumnLabelPrimaryKey", ",", "types", ".", "SQLColumnLabelColumnOrder", ",", "tableName", ",", "columnName", ",", "sqlColumnType", ",", "length", ",", "0", ",", "order", ")", "\n\n", "return", "query", ",", "dictionaryQuery", "\n", "}" ]

[ "AlterColumnQuery", "returns", "a", "query", "for", "adding", "a", "new", "column", "to", "a", "table" ]

[ "func", "(", "pf", "PermFlag", ")", "String", "(", ")", "string", "{", "switch", "pf", "{", "case", "AllPermFlags", ":", "return", "AllString", "\n", "case", "Root", ":", "return", "RootString", "\n", "case", "Send", ":", "return", "SendString", "\n", "case", "Call", ":", "return", "CallString", "\n", "case", "CreateContract", ":", "return", "CreateContractString", "\n", "case", "CreateAccount", ":", "return", "CreateAccountString", "\n", "case", "Bond", ":", "return", "BondString", "\n", "case", "Name", ":", "return", "NameString", "\n", "case", "Proposal", ":", "return", "ProposalString", "\n", "case", "Input", ":", "return", "InputString", "\n", "case", "Batch", ":", "return", "BatchString", "\n", "case", "HasBase", ":", "return", "HasBaseString", "\n", "case", "SetBase", ":", "return", "SetBaseString", "\n", "case", "UnsetBase", ":", "return", "UnsetBaseString", "\n", "case", "SetGlobal", ":", "return", "SetGlobalString", "\n", "case", "HasRole", ":", "return", "HasRoleString", "\n", "case", "AddRole", ":", "return", "AddRoleString", "\n", "case", "RemoveRole", ":", "return", "RemoveRoleString", "\n", "default", ":", "return", "UnknownString", "\n", "}", "\n", "}" ]

[ "Returns", "the", "string", "name", "of", "a", "single", "bit", "non", "-", "composite", "PermFlag", "or", "otherwise", "UnknownString", "See", "BasePermissionsToStringList", "to", "generate", "a", "string", "representation", "of", "a", "composite", "PermFlag" ]

[ "func", "PermStringToFlag", "(", "perm", "string", ")", "(", "PermFlag", ",", "error", ")", "{", "switch", "strings", ".", "ToLower", "(", "perm", ")", "{", "case", "AllString", ":", "return", "AllPermFlags", ",", "nil", "\n", "case", "RootString", ":", "return", "Root", ",", "nil", "\n", "case", "SendString", ":", "return", "Send", ",", "nil", "\n", "case", "CallString", ":", "return", "Call", ",", "nil", "\n", "case", "CreateContractString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "CreateContract", ",", "nil", "\n", "case", "CreateAccountString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "CreateAccount", ",", "nil", "\n", "case", "BondString", ":", "return", "Bond", ",", "nil", "\n", "case", "NameString", ":", "return", "Name", ",", "nil", "\n", "case", "ProposalString", ":", "return", "Proposal", ",", "nil", "\n", "case", "InputString", ":", "return", "Input", ",", "nil", "\n", "case", "BatchString", ":", "return", "Batch", ",", "nil", "\n", "case", "HasBaseString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "HasBase", ",", "nil", "\n", "case", "SetBaseString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "SetBase", ",", "nil", "\n", "case", "UnsetBaseString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "UnsetBase", ",", "nil", "\n", "case", "SetGlobalString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "SetGlobal", ",", "nil", "\n", "case", "HasRoleString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "HasRole", ",", "nil", "\n", "case", "AddRoleString", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "AddRole", ",", "nil", "\n", "case", "RemoveRoleString", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "RemoveRole", ",", "nil", "\n", "default", ":", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "perm", ")", "\n", "}", "\n", "}" ]

[ "PermStringToFlag", "maps", "camel", "-", "and", "snake", "case", "strings", "to", "the", "the", "corresponding", "permission", "flag", "." ]

[ "func", "(", "n", "*", "Node", ")", "DBProvider", "(", "ctx", "*", "node", ".", "DBContext", ")", "(", "dbm", ".", "DB", ",", "error", ")", "{", "db", ":=", "DBProvider", "(", "ctx", ".", "ID", ",", "dbm", ".", "DBBackendType", "(", "ctx", ".", "Config", ".", "DBBackend", ")", ",", "ctx", ".", "Config", ".", "DBDir", "(", ")", ")", "\n", "n", ".", "closers", "=", "append", "(", "n", ".", "closers", ",", "db", ")", "\n", "return", "db", ",", "nil", "\n", "}" ]

[ "Since", "Tendermint", "doesn", "t", "close", "its", "DB", "connections" ]

[ "func", "NewLogger", "(", "level", "string", ")", "*", "Logger", "{", "log", ":=", "kitlog", ".", "NewJSONLogger", "(", "kitlog", ".", "NewSyncWriter", "(", "os", ".", "Stdout", ")", ")", "\n", "switch", "level", "{", "case", "\"", "\"", ":", "log", "=", "kitlevel", ".", "NewFilter", "(", "log", ",", "kitlevel", ".", "AllowError", "(", ")", ")", "// only error logs", "\n", "case", "\"", "\"", ":", "log", "=", "kitlevel", ".", "NewFilter", "(", "log", ",", "kitlevel", ".", "AllowWarn", "(", ")", ")", "// warn + error logs", "\n", "case", "\"", "\"", ":", "log", "=", "kitlevel", ".", "NewFilter", "(", "log", ",", "kitlevel", ".", "AllowInfo", "(", ")", ")", "// info + warn + error logs", "\n", "case", "\"", "\"", ":", "log", "=", "kitlevel", ".", "NewFilter", "(", "log", ",", "kitlevel", ".", "AllowDebug", "(", ")", ")", "// all logs", "\n", "default", ":", "log", "=", "kitlevel", ".", "NewFilter", "(", "log", ",", "kitlevel", ".", "AllowNone", "(", ")", ")", "// no logs", "\n", "}", "\n\n", "log", "=", "kitlog", ".", "With", "(", "log", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "log", "=", "kitlog", ".", "With", "(", "log", ",", "\"", "\"", ",", "kitlog", ".", "DefaultTimestampUTC", ")", "\n", "log", "=", "kitlog", ".", "With", "(", "log", ",", "\"", "\"", ",", "kitlog", ".", "Caller", "(", "4", ")", ")", "\n\n", "return", "&", "Logger", "{", "Log", ":", "log", ",", "}", "\n", "}" ]

[ "NewLogger", "creates", "a", "new", "logger", "based", "on", "the", "given", "level" ]

[ "func", "(", "l", "*", "Logger", ")", "Error", "(", "args", "...", "interface", "{", "}", ")", "{", "kitlevel", ".", "Error", "(", "l", ".", "Log", ")", ".", "Log", "(", "args", "...", ")", "\n", "}" ]

[ "Error", "prints", "an", "error", "log" ]

[ "func", "(", "l", "*", "Logger", ")", "Warn", "(", "args", "...", "interface", "{", "}", ")", "{", "kitlevel", ".", "Warn", "(", "l", ".", "Log", ")", ".", "Log", "(", "args", "...", ")", "\n", "}" ]

[ "Warn", "prints", "a", "warning", "log" ]

[ "func", "(", "l", "*", "Logger", ")", "Info", "(", "args", "...", "interface", "{", "}", ")", "{", "kitlevel", ".", "Info", "(", "l", ".", "Log", ")", ".", "Log", "(", "args", "...", ")", "\n", "}" ]

[ "Info", "prints", "an", "information", "log" ]

[ "func", "(", "l", "*", "Logger", ")", "Debug", "(", "args", "...", "interface", "{", "}", ")", "{", "kitlevel", ".", "Debug", "(", "l", ".", "Log", ")", ".", "Log", "(", "args", "...", ")", "\n", "}" ]

[ "Debug", "prints", "a", "debug", "log" ]

[ "func", "(", "ta", "TemplateAccount", ")", "RealisePublicKeyAndAddress", "(", "keyClient", "keys", ".", "KeyClient", ")", "(", "pubKey", "crypto", ".", "PublicKey", ",", "address", "crypto", ".", "Address", ",", "err", "error", ")", "{", "if", "ta", ".", "PublicKey", "==", "nil", "{", "if", "ta", ".", "Address", "==", "nil", "{", "// If neither PublicKey or Address set then generate a new one", "address", ",", "err", "=", "keyClient", ".", "Generate", "(", "ta", ".", "Name", ",", "crypto", ".", "CurveTypeEd25519", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "else", "{", "address", "=", "*", "ta", ".", "Address", "\n", "}", "\n", "// Get the (possibly existing) key", "pubKey", ",", "err", "=", "keyClient", ".", "PublicKey", "(", "address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "else", "{", "address", "=", "(", "*", "ta", ".", "PublicKey", ")", ".", "GetAddress", "(", ")", "\n", "if", "ta", ".", "Address", "!=", "nil", "&&", "*", "ta", ".", "Address", "!=", "address", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ta", ".", "Address", ",", "ta", ".", "PublicKey", ")", "\n", "}", "\n", "pubKey", "=", "*", "ta", ".", "PublicKey", "\n", "}", "\n", "return", "\n", "}" ]

[ "Adds", "a", "public", "key", "and", "address", "to", "the", "template", ".", "If", "PublicKey", "will", "try", "to", "fetch", "it", "by", "Address", ".", "If", "both", "PublicKey", "and", "Address", "are", "not", "set", "will", "use", "the", "keyClient", "to", "generate", "a", "new", "keypair" ]

[ "func", "ExecuteTx", "(", "logHeader", "string", ",", "executor", "execution", ".", "Executor", ",", "txDecoder", "txs", ".", "Decoder", ",", "txBytes", "[", "]", "byte", ")", "types", ".", "ResponseCheckTx", "{", "logf", ":=", "func", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "format", ",", "append", "(", "[", "]", "interface", "{", "}", "{", "logHeader", "}", ",", "args", "...", ")", "...", ")", "\n", "}", "\n\n", "txEnv", ",", "err", ":=", "txDecoder", ".", "DecodeTx", "(", "txBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "types", ".", "ResponseCheckTx", "{", "Code", ":", "codes", ".", "EncodingErrorCode", ",", "Log", ":", "logf", "(", "\"", "\"", ",", "err", ")", ",", "}", "\n", "}", "\n", "tags", ":=", "[", "]", "common", ".", "KVPair", "{", "{", "Key", ":", "[", "]", "byte", "(", "structure", ".", "TxHashKey", ")", ",", "Value", ":", "[", "]", "byte", "(", "txEnv", ".", "Tx", ".", "Hash", "(", ")", ".", "String", "(", ")", ")", "}", "}", "\n\n", "txe", ",", "err", ":=", "executor", ".", "Execute", "(", "txEnv", ")", "\n", "if", "err", "!=", "nil", "{", "ex", ":=", "errors", ".", "AsException", "(", "err", ")", "\n", "return", "types", ".", "ResponseCheckTx", "{", "Code", ":", "codes", ".", "TxExecutionErrorCode", ",", "Tags", ":", "tags", ",", "Log", ":", "logf", "(", "\"", "\"", ",", "txEnv", ",", "ex", ".", "Exception", ")", ",", "}", "\n", "}", "\n\n", "if", "txe", ".", "Receipt", ".", "CreatesContract", "{", "tags", "=", "append", "(", "tags", ",", "common", ".", "KVPair", "{", "Key", ":", "[", "]", "byte", "(", "\"", "\"", ")", ",", "Value", ":", "[", "]", "byte", "(", "txe", ".", "Receipt", ".", "ContractAddress", ".", "String", "(", ")", ")", ",", "}", ")", "\n", "}", "\n\n", "bs", ",", "err", ":=", "txe", ".", "Receipt", ".", "Encode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "types", ".", "ResponseCheckTx", "{", "Code", ":", "codes", ".", "EncodingErrorCode", ",", "Tags", ":", "tags", ",", "Log", ":", "logf", "(", "\"", "\"", ",", "err", ")", ",", "}", "\n", "}", "\n", "return", "types", ".", "ResponseCheckTx", "{", "Code", ":", "codes", ".", "TxExecutionSuccessCode", ",", "Tags", ":", "tags", ",", "Log", ":", "logf", "(", "\"", "\"", ")", ",", "Data", ":", "bs", ",", "}", "\n", "}" ]

[ "Attempt", "to", "execute", "a", "transaction", "using", "ABCI", "conventions", "and", "codes" ]

[ "func", "WithTags", "(", "logger", "*", "logging", ".", "Logger", ",", "tags", "[", "]", "common", ".", "KVPair", ")", "*", "logging", ".", "Logger", "{", "keyvals", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "len", "(", "tags", ")", "*", "2", ")", "\n", "for", "i", ",", "kvp", ":=", "range", "tags", "{", "keyvals", "[", "i", "]", "=", "string", "(", "kvp", ".", "Key", ")", "\n", "keyvals", "[", "i", "+", "1", "]", "=", "string", "(", "kvp", ".", "Value", ")", "\n", "}", "\n", "return", "logger", ".", "With", "(", "keyvals", "...", ")", "\n", "}" ]

[ "Some", "ABCI", "type", "helpers" ]

[ "func", "jsonParamsToArgsWS", "(", "rpcFunc", "*", "RPCFunc", ",", "params", "json", ".", "RawMessage", ",", "wsCtx", "types", ".", "WSRPCContext", ")", "(", "[", "]", "reflect", ".", "Value", ",", "error", ")", "{", "values", ",", "err", ":=", "jsonParamsToArgs", "(", "rpcFunc", ",", "params", ",", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "append", "(", "[", "]", "reflect", ".", "Value", "{", "reflect", ".", "ValueOf", "(", "wsCtx", ")", "}", ",", "values", "...", ")", ",", "nil", "\n", "}" ]

[ "Same", "as", "above", "but", "with", "the", "first", "param", "the", "websocket", "connection" ]

[ "func", "NewWebsocketManager", "(", "funcMap", "map", "[", "string", "]", "*", "RPCFunc", ",", "logger", "*", "logging", ".", "Logger", ",", "wsConnOptions", "...", "func", "(", "*", "wsConnection", ")", ")", "*", "WebsocketManager", "{", "return", "&", "WebsocketManager", "{", "funcMap", ":", "funcMap", ",", "Upgrader", ":", "websocket", ".", "Upgrader", "{", "CheckOrigin", ":", "func", "(", "r", "*", "http", ".", "Request", ")", "bool", "{", "// TODO ???", "return", "true", "\n", "}", ",", "}", ",", "logger", ":", "logger", ",", "wsConnOptions", ":", "wsConnOptions", ",", "}", "\n", "}" ]

[ "NewWebsocketManager", "returns", "a", "new", "WebsocketManager", "that", "routes", "according", "to", "the", "given", "funcMap", "and", "connects", "to", "the", "server", "with", "the", "given", "connection", "options", "." ]

[ "func", "(", "lsi", "*", "LastSignedInfo", ")", "checkHRS", "(", "height", "int64", ",", "round", "int", ",", "step", "int8", ")", "(", "bool", ",", "error", ")", "{", "if", "lsi", ".", "Height", ">", "height", "{", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "lsi", ".", "Height", "==", "height", "{", "if", "lsi", ".", "Round", ">", "round", "{", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "lsi", ".", "Round", "==", "round", "{", "if", "lsi", ".", "Step", ">", "step", "{", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "lsi", ".", "Step", "==", "step", "{", "if", "lsi", ".", "SignBytes", "!=", "nil", "{", "if", "lsi", ".", "Signature", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}", "\n", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "returns", "error", "if", "HRS", "regression", "or", "no", "SignBytes", ".", "returns", "true", "if", "HRS", "is", "unchanged" ]

[ "func", "(", "lsi", "*", "LastSignedInfo", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "lsi", ".", "Height", ",", "lsi", ".", "Round", ",", "lsi", ".", "Step", ")", "\n", "}" ]

[ "String", "returns", "a", "string", "representation", "of", "the", "LastSignedInfo", "." ]

[ "func", "(", "contract", "*", "solidityContract", ")", "InstanceName", "(", ")", "string", "{", "// Hopefully the contract name is UpperCamelCase. If it's not, oh well, this", "// is meant to be illustrative rather than cast iron compilable", "instanceName", ":=", "strings", ".", "ToLower", "(", "contract", ".", "Name", "[", ":", "1", "]", ")", "+", "contract", ".", "Name", "[", "1", ":", "]", "\n", "if", "instanceName", "==", "contract", ".", "Name", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "instanceName", "\n", "}" ]

[ "Get", "a", "version", "of", "the", "contract", "name", "to", "be", "used", "for", "an", "instance", "of", "the", "contract" ]

[ "func", "(", "contract", "*", "solidityContract", ")", "Solidity", "(", ")", "(", "string", ",", "error", ")", "{", "buf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "err", ":=", "contractTemplate", ".", "Execute", "(", "buf", ",", "contract", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "buf", ".", "String", "(", ")", ",", "nil", "\n", "}" ]

[ "Generate", "Solidity", "code", "for", "this", "SNative", "contract" ]

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

[ "clean", "queries", "from", "tabs", "spaces", "and", "returns" ]

[ "func", "(", "cl", "*", "ChannelLogger", ")", "WaitReadLogLine", "(", ")", "[", "]", "interface", "{", "}", "{", "logLine", ",", "ok", ":=", "<-", "cl", ".", "ch", ".", "Out", "(", ")", "\n", "return", "readLogLine", "(", "logLine", ",", "ok", ")", "\n", "}" ]

[ "Read", "a", "log", "line", "by", "waiting", "until", "one", "is", "available", "and", "returning", "it" ]

[ "func", "(", "cl", "*", "ChannelLogger", ")", "ReadLogLine", "(", ")", "[", "]", "interface", "{", "}", "{", "select", "{", "case", "logLine", ",", "ok", ":=", "<-", "cl", ".", "ch", ".", "Out", "(", ")", ":", "return", "readLogLine", "(", "logLine", ",", "ok", ")", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}" ]

[ "Tries", "to", "read", "a", "log", "line", "from", "the", "channel", "buffer", "or", "returns", "nil", "if", "none", "is", "immediately", "available" ]

[ "func", "(", "cl", "*", "ChannelLogger", ")", "DrainForever", "(", "logger", "log", ".", "Logger", ",", "errCh", "channels", ".", "Channel", ")", "{", "// logLine could be nil if channel was closed while waiting for next line", "for", "logLine", ":=", "cl", ".", "WaitReadLogLine", "(", ")", ";", "logLine", "!=", "nil", ";", "logLine", "=", "cl", ".", "WaitReadLogLine", "(", ")", "{", "err", ":=", "logger", ".", "Log", "(", "logLine", "...", ")", "\n", "if", "err", "!=", "nil", "&&", "errCh", "!=", "nil", "{", "errCh", ".", "In", "(", ")", "<-", "err", "\n", "}", "\n", "}", "\n", "}" ]

[ "Enters", "an", "infinite", "loop", "that", "will", "drain", "any", "log", "lines", "from", "the", "passed", "logger", ".", "You", "may", "pass", "in", "a", "channel", "Exits", "if", "the", "channel", "is", "closed", "." ]

[ "func", "(", "cl", "*", "ChannelLogger", ")", "Flush", "(", "logger", "log", ".", "Logger", ")", "error", "{", "// Grab the buffer at the here rather than within loop condition so that we", "// do not drain the buffer forever", "cl", ".", "Lock", "(", ")", "\n", "defer", "cl", ".", "Unlock", "(", ")", "\n", "bufferLength", ":=", "cl", ".", "BufferLength", "(", ")", "\n", "var", "errs", "[", "]", "error", "\n", "for", "i", ":=", "0", ";", "i", "<", "bufferLength", ";", "i", "++", "{", "logLine", ":=", "cl", ".", "WaitReadLogLine", "(", ")", "\n", "if", "logLine", "!=", "nil", "{", "err", ":=", "logger", ".", "Log", "(", "logLine", "...", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "CombineErrors", "(", "errs", ")", "\n", "}" ]

[ "Drains", "everything", "that", "is", "available", "at", "the", "time", "of", "calling" ]

[ "func", "(", "cl", "*", "ChannelLogger", ")", "FlushLogLines", "(", ")", "[", "]", "[", "]", "interface", "{", "}", "{", "logLines", ":=", "make", "(", "[", "]", "[", "]", "interface", "{", "}", ",", "0", ",", "cl", ".", "ch", ".", "Len", "(", ")", ")", "\n", "cl", ".", "Flush", "(", "log", ".", "LoggerFunc", "(", "func", "(", "keyvals", "...", "interface", "{", "}", ")", "error", "{", "logLines", "=", "append", "(", "logLines", ",", "keyvals", ")", "\n", "return", "nil", "\n", "}", ")", ")", "\n", "return", "logLines", "\n", "}" ]

[ "Drains", "the", "next", "contiguous", "segment", "of", "loglines", "up", "to", "the", "buffer", "cap", "waiting", "for", "at", "least", "one", "line" ]

[ "func", "(", "cl", "*", "ChannelLogger", ")", "Reset", "(", ")", "{", "cl", ".", "RWMutex", ".", "Lock", "(", ")", "\n", "defer", "cl", ".", "RWMutex", ".", "Unlock", "(", ")", "\n", "cl", ".", "ch", ".", "Close", "(", ")", "\n", "cl", ".", "ch", "=", "channels", ".", "NewRingChannel", "(", "cl", ".", "ch", ".", "Cap", "(", ")", ")", "\n", "}" ]

[ "Close", "the", "existing", "channel", "halting", "goroutines", "that", "are", "draining", "the", "channel", "and", "create", "a", "new", "channel", "to", "buffer", "into", ".", "Should", "not", "cause", "any", "log", "lines", "arriving", "concurrently", "to", "be", "lost", "but", "any", "that", "have", "not", "been", "drained", "from", "old", "channel", "may", "be", "." ]

[ "func", "NonBlockingLogger", "(", "outputLogger", "log", ".", "Logger", ")", "(", "*", "ChannelLogger", ",", "channels", ".", "Channel", ")", "{", "cl", ":=", "NewChannelLogger", "(", "DefaultLoggingRingBufferCap", ")", "\n", "errCh", ":=", "channels", ".", "NewRingChannel", "(", "cl", ".", "BufferCap", "(", ")", ")", "\n", "go", "cl", ".", "DrainForever", "(", "outputLogger", ",", "errCh", ")", "\n", "return", "cl", ",", "errCh", "\n", "}" ]

[ "Returns", "a", "Logger", "that", "wraps", "the", "outputLogger", "passed", "and", "does", "not", "block", "on", "calls", "to", "Log", "and", "a", "channel", "of", "any", "errors", "from", "the", "underlying", "logger" ]

[ "func", "NewState", "(", "db", "dbm", ".", "DB", ")", "*", "State", "{", "forest", ",", "err", ":=", "storage", ".", "NewMutableForest", "(", "storage", ".", "NewPrefixDB", "(", "db", ",", "forestPrefix", ")", ",", "defaultCacheCapacity", ")", "\n", "if", "err", "!=", "nil", "{", "// This should only happen if we have negative cache capacity, which for us is a positive compile-time constant", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "ring", ":=", "validator", ".", "NewRing", "(", "nil", ",", "DefaultValidatorsWindowSize", ")", "\n", "rs", ":=", "ReadState", "{", "Forest", ":", "forest", ",", "History", ":", "ring", "}", "\n", "ws", ":=", "writeState", "{", "forest", ":", "forest", ",", "ring", ":", "ring", "}", "\n", "return", "&", "State", "{", "db", ":", "db", ",", "ReadState", ":", "rs", ",", "writeState", ":", "ws", ",", "logger", ":", "logging", ".", "NewNoopLogger", "(", ")", ",", "}", "\n", "}" ]

[ "Create", "a", "new", "State", "object" ]

[ "func", "MakeGenesisState", "(", "db", "dbm", ".", "DB", ",", "genesisDoc", "*", "genesis", ".", "GenesisDoc", ")", "(", "*", "State", ",", "error", ")", "{", "s", ":=", "NewState", "(", "db", ")", "\n\n", "const", "errHeader", "=", "\"", "\"", "\n", "// Make accounts state tree", "for", "_", ",", "genAcc", ":=", "range", "genesisDoc", ".", "Accounts", "{", "perm", ":=", "genAcc", ".", "Permissions", "\n", "acc", ":=", "&", "acm", ".", "Account", "{", "Address", ":", "genAcc", ".", "Address", ",", "Balance", ":", "genAcc", ".", "Amount", ",", "Permissions", ":", "perm", ",", "}", "\n", "err", ":=", "s", ".", "writeState", ".", "UpdateAccount", "(", "acc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "errHeader", ",", "err", ")", "\n", "}", "\n", "}", "\n", "// Make genesis validators", "err", ":=", "s", ".", "writeState", ".", "MakeGenesisValidators", "(", "genesisDoc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "errHeader", ",", "err", ")", "\n", "}", "\n", "// global permissions are saved as the 0 address", "// so they are included in the accounts tree", "globalPerms", ":=", "permission", ".", "DefaultAccountPermissions", "\n", "globalPerms", "=", "genesisDoc", ".", "GlobalPermissions", "\n", "// XXX: make sure the set bits are all true", "// Without it the HasPermission() functions will fail", "globalPerms", ".", "Base", ".", "SetBit", "=", "permission", ".", "AllPermFlags", "\n\n", "permsAcc", ":=", "&", "acm", ".", "Account", "{", "Address", ":", "acm", ".", "GlobalPermissionsAddress", ",", "Balance", ":", "1337", ",", "Permissions", ":", "globalPerms", ",", "}", "\n", "err", "=", "s", ".", "writeState", ".", "UpdateAccount", "(", "permsAcc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "errHeader", ",", "err", ")", "\n", "}", "\n\n", "return", "s", ",", "nil", "\n", "}" ]

[ "Make", "genesis", "state", "from", "GenesisDoc", "and", "save", "to", "DB" ]

[ "func", "(", "s", "*", "State", ")", "Update", "(", "updater", "func", "(", "up", "Updatable", ")", "error", ")", "(", "[", "]", "byte", ",", "int64", ",", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n", "err", ":=", "updater", "(", "&", "s", ".", "writeState", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "s", ".", "commit", "(", ")", "\n", "}" ]

[ "Perform", "updates", "to", "state", "whilst", "holding", "the", "write", "lock", "allows", "a", "commit", "to", "hold", "the", "write", "lock", "across", "multiple", "operations", "while", "preventing", "interlaced", "reads", "and", "writes" ]

[ "func", "(", "s", "*", "State", ")", "Copy", "(", "db", "dbm", ".", "DB", ")", "(", "*", "State", ",", "error", ")", "{", "stateCopy", ":=", "NewState", "(", "db", ")", "\n", "err", ":=", "s", ".", "writeState", ".", "forest", ".", "IterateRWTree", "(", "nil", ",", "nil", ",", "true", ",", "func", "(", "prefix", "[", "]", "byte", ",", "tree", "*", "storage", ".", "RWTree", ")", "error", "{", "treeCopy", ",", "err", ":=", "stateCopy", ".", "writeState", ".", "forest", ".", "Writer", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "tree", ".", "IterateWriteTree", "(", "nil", ",", "nil", ",", "true", ",", "func", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ")", "error", "{", "treeCopy", ".", "Set", "(", "key", ",", "value", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "_", ",", "_", ",", "err", "=", "stateCopy", ".", "commit", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "stateCopy", ",", "nil", "\n", "}" ]

[ "Creates", "a", "copy", "of", "the", "database", "to", "the", "supplied", "db" ]

[ "func", "NewSQLDB", "(", "connection", "types", ".", "SQLConnection", ")", "(", "*", "SQLDB", ",", "error", ")", "{", "db", ":=", "&", "SQLDB", "{", "Schema", ":", "connection", ".", "DBSchema", ",", "Log", ":", "connection", ".", "Log", ",", "}", "\n\n", "var", "url", "string", "\n\n", "switch", "connection", ".", "DBAdapter", "{", "case", "types", ".", "PostgresDB", ":", "db", ".", "DBAdapter", "=", "adapters", ".", "NewPostgresAdapter", "(", "safe", "(", "connection", ".", "DBSchema", ")", ",", "connection", ".", "Log", ")", "\n", "url", "=", "connection", ".", "DBURL", "\n\n", "case", "types", ".", "SQLiteDB", ":", "db", ".", "DBAdapter", "=", "adapters", ".", "NewSQLiteAdapter", "(", "connection", ".", "Log", ")", "\n", "// \"?_journal_mode=WAL\" parameter is necessary to prevent database locking", "url", "=", "connection", ".", "DBURL", "+", "\"", "\"", "\n\n", "default", ":", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "err", "error", "\n", "db", ".", "DB", ",", "err", "=", "db", ".", "DBAdapter", ".", "Open", "(", "url", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", "=", "db", ".", "Ping", "(", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "// Create dictionary and log tables", "sysTables", ":=", "db", ".", "getSysTablesDefinition", "(", ")", "\n\n", "// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (1)", "if", "err", "=", "db", ".", "createTable", "(", "sysTables", "[", "types", ".", "SQLDictionaryTableName", "]", ",", "true", ")", ";", "err", "!=", "nil", "{", "if", "!", "db", ".", "DBAdapter", ".", "ErrorEquals", "(", "err", ",", "types", ".", "SQLErrorTypeDuplicatedTable", ")", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (2)", "if", "err", "=", "db", ".", "createTable", "(", "sysTables", "[", "types", ".", "SQLLogTableName", "]", ",", "true", ")", ";", "err", "!=", "nil", "{", "if", "!", "db", ".", "DBAdapter", ".", "ErrorEquals", "(", "err", ",", "types", ".", "SQLErrorTypeDuplicatedTable", ")", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (3)", "if", "err", "=", "db", ".", "createTable", "(", "sysTables", "[", "types", ".", "SQLChainInfoTableName", "]", ",", "true", ")", ";", "err", "!=", "nil", "{", "if", "!", "db", ".", "DBAdapter", ".", "ErrorEquals", "(", "err", ",", "types", ".", "SQLErrorTypeDuplicatedTable", ")", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "if", "err", "=", "db", ".", "CleanTables", "(", "connection", ".", "ChainID", ",", "connection", ".", "BurrowVersion", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "db", ",", "nil", "\n", "}" ]

[ "NewSQLDB", "delegates", "work", "to", "a", "specific", "database", "adapter", "implementation", "opens", "database", "connection", "and", "create", "log", "tables" ]

[ "func", "(", "db", "*", "SQLDB", ")", "Close", "(", ")", "{", "if", "err", ":=", "db", ".", "DB", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "Close", "database", "connection" ]

[ "func", "(", "db", "*", "SQLDB", ")", "GetLastBlockHeight", "(", ")", "(", "uint64", ",", "error", ")", "{", "query", ":=", "db", ".", "DBAdapter", ".", "LastBlockIDQuery", "(", ")", "\n", "id", ":=", "\"", "\"", "\n\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ")", "\n\n", "if", "err", ":=", "db", ".", "DB", ".", "QueryRow", "(", "query", ")", ".", "Scan", "(", "&", "id", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "0", ",", "err", "\n", "}", "\n", "height", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "id", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "height", ",", "nil", "\n", "}" ]

[ "GetLastBlockID", "returns", "last", "inserted", "blockId", "from", "log", "table" ]

[ "func", "(", "db", "*", "SQLDB", ")", "SynchronizeDB", "(", "eventTables", "types", ".", "EventTables", ")", "error", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "for", "_", ",", "table", ":=", "range", "eventTables", "{", "found", ",", "err", ":=", "db", ".", "findTable", "(", "table", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "found", "{", "err", "=", "db", ".", "alterTable", "(", "table", ")", "\n", "}", "else", "{", "err", "=", "db", ".", "createTable", "(", "table", ",", "false", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SynchronizeDB", "synchronize", "db", "tables", "structures", "from", "given", "tables", "specifications" ]

[ "func", "(", "db", "*", "SQLDB", ")", "GetBlock", "(", "height", "uint64", ")", "(", "types", ".", "EventData", ",", "error", ")", "{", "var", "data", "types", ".", "EventData", "\n", "data", ".", "BlockHeight", "=", "height", "\n", "data", ".", "Tables", "=", "make", "(", "map", "[", "string", "]", "types", ".", "EventDataTable", ")", "\n\n", "// get all table structures involved in the block", "tables", ",", "err", ":=", "db", ".", "getBlockTables", "(", "height", ")", "\n", "if", "err", "!=", "nil", "{", "return", "data", ",", "err", "\n", "}", "\n\n", "query", ":=", "\"", "\"", "\n\n", "// for each table", "for", "_", ",", "table", ":=", "range", "tables", "{", "// get query for table", "query", ",", "err", "=", "db", ".", "getSelectQuery", "(", "table", ",", "height", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "data", ",", "err", "\n", "}", "\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ")", "\n", "rows", ",", "err", ":=", "db", ".", "DB", ".", "Query", "(", "query", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "data", ",", "err", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "cols", ",", "err", ":=", "rows", ".", "Columns", "(", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "data", ",", "err", "\n", "}", "\n\n", "// builds pointers", "length", ":=", "len", "(", "cols", ")", "\n", "pointers", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "length", ")", "\n", "containers", ":=", "make", "(", "[", "]", "sql", ".", "NullString", ",", "length", ")", "\n\n", "for", "i", ":=", "range", "pointers", "{", "pointers", "[", "i", "]", "=", "&", "containers", "[", "i", "]", "\n", "}", "\n\n", "// for each row in table", "var", "dataRows", "[", "]", "types", ".", "EventDataRow", "\n\n", "for", "rows", ".", "Next", "(", ")", "{", "row", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "if", "err", "=", "rows", ".", "Scan", "(", "pointers", "...", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "data", ",", "err", "\n", "}", "\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "containers", ")", ")", "\n\n", "// for each column in row", "for", "i", ",", "col", ":=", "range", "cols", "{", "// add value if not null", "if", "containers", "[", "i", "]", ".", "Valid", "{", "row", "[", "col", "]", "=", "containers", "[", "i", "]", ".", "String", "\n", "}", "\n", "}", "\n", "dataRows", "=", "append", "(", "dataRows", ",", "types", ".", "EventDataRow", "{", "Action", ":", "types", ".", "ActionRead", ",", "RowData", ":", "row", "}", ")", "\n", "}", "\n\n", "if", "err", "=", "rows", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "data", ",", "err", "\n", "}", "\n", "data", ".", "Tables", "[", "table", ".", "Name", "]", "=", "dataRows", "\n", "}", "\n", "return", "data", ",", "nil", "\n", "}" ]

[ "GetBlock", "returns", "all", "tables", "structures", "and", "row", "data", "for", "given", "block" ]

[ "func", "(", "db", "*", "SQLDB", ")", "RestoreDB", "(", "time", "time", ".", "Time", ",", "prefix", "string", ")", "error", "{", "const", "yymmddhhmmss", "=", "\"", "\"", "\n\n", "var", "pointers", "[", "]", "interface", "{", "}", "\n\n", "if", "prefix", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Get Restore DB query", "query", ":=", "db", ".", "DBAdapter", ".", "RestoreDBQuery", "(", ")", "\n", "strTime", ":=", "time", ".", "Format", "(", "yymmddhhmmss", ")", "\n\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "// Open rows", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ")", "\n", "rows", ",", "err", ":=", "db", ".", "DB", ".", "Query", "(", "query", ",", "strTime", ")", "\n", "if", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "// For each row returned", "for", "rows", ".", "Next", "(", ")", "{", "var", "tableName", ",", "sqlSmt", ",", "sqlValues", "string", "\n", "var", "action", "types", ".", "DBAction", "\n\n", "if", "err", "=", "rows", ".", "Scan", "(", "&", "tableName", ",", "&", "action", ",", "&", "sqlSmt", ",", "&", "sqlValues", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "rows", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "restoreTable", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "prefix", ",", "tableName", ")", "\n\n", "switch", "action", "{", "case", "types", ".", "ActionUpsert", ",", "types", ".", "ActionDelete", ":", "// get row values", "if", "pointers", ",", "err", "=", "db", ".", "getValuesFromJSON", "(", "sqlValues", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "sqlValues", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Prepare Upsert/delete", "query", "=", "strings", ".", "Replace", "(", "sqlSmt", ",", "tableName", ",", "restoreTable", ",", "-", "1", ")", "\n\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ")", "\n", "if", "_", ",", "err", "=", "db", ".", "DB", ".", "Exec", "(", "query", ",", "pointers", "...", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "sqlSmt", ",", "\"", "\"", ",", "sqlValues", ")", "\n", "return", "err", "\n", "}", "\n\n", "case", "types", ".", "ActionAlterTable", ",", "types", ".", "ActionCreateTable", ":", "// Prepare Alter/Create Table", "query", "=", "strings", ".", "Replace", "(", "sqlSmt", ",", "tableName", ",", "restoreTable", ",", "-", "1", ")", "\n\n", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ")", "\n", "if", "_", ",", "err", "=", "db", ".", "DB", ".", "Exec", "(", "query", ")", ";", "err", "!=", "nil", "{", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "sqlSmt", ")", "\n", "return", "err", "\n", "}", "\n", "default", ":", "// Invalid Action", "db", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "action", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "action", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RestoreDB", "restores", "the", "DB", "to", "a", "given", "moment", "in", "time" ]

[ "func", "(", "imf", "*", "ImmutableForest", ")", "Reader", "(", "prefix", "[", "]", "byte", ")", "(", "KVCallbackIterableReader", ",", "error", ")", "{", "return", "imf", ".", "tree", "(", "prefix", ")", "\n", "}" ]

[ "Get", "the", "tree", "at", "prefix", "for", "making", "reads" ]

[ "func", "(", "imf", "*", "ImmutableForest", ")", "tree", "(", "prefix", "[", "]", "byte", ")", "(", "*", "RWTree", ",", "error", ")", "{", "// Try cache", "if", "value", ",", "ok", ":=", "imf", ".", "treeCache", ".", "Get", "(", "string", "(", "prefix", ")", ")", ";", "ok", "{", "return", "value", ".", "(", "*", "RWTree", ")", ",", "nil", "\n", "}", "\n", "// Not in caches but non-negative version - we should be able to load into memory", "return", "imf", ".", "loadOrCreateTree", "(", "prefix", ")", "\n", "}" ]

[ "Lazy", "load", "tree" ]

[ "func", "(", "imf", "*", "ImmutableForest", ")", "newTree", "(", "prefix", "[", "]", "byte", ")", "*", "RWTree", "{", "p", ":=", "string", "(", "prefix", ")", "\n", "tree", ":=", "NewRWTree", "(", "NewPrefixDB", "(", "imf", ".", "treeDB", ",", "p", ")", ",", "imf", ".", "cacheSize", ")", "\n", "imf", ".", "treeCache", ".", "Add", "(", "p", ",", "tree", ")", "\n", "return", "tree", "\n", "}" ]

[ "Create", "a", "new", "in", "-", "memory", "IAVL", "tree" ]

[ "func", "stripBraces", "(", "str", "string", ")", "string", "{", "bs", ":=", "[", "]", "byte", "(", "str", ")", "\n", "const", "lb", "=", "byte", "(", "'{'", ")", "\n", "const", "rb", "=", "byte", "(", "'}'", ")", "\n", "start", ":=", "0", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "bs", ")", ";", "i", "++", "{", "switch", "bs", "[", "i", "]", "{", "case", "lb", ":", "start", "=", "i", "+", "1", "\n", "case", "rb", ":", "return", "`\\$`", "+", "str", "[", "start", ":", "i", "]", "\n", "}", "\n", "}", "\n", "return", "str", "[", "start", ":", "]", "\n", "}" ]

[ "Strips", "braces", "and", "return", "simple", "variable", "confined", "between", "braces" ]

[ "func", "IsOmitted", "(", "value", "interface", "{", "}", ")", "bool", "{", "value", ",", "isNil", ":=", "validation", ".", "Indirect", "(", "value", ")", "\n", "if", "isNil", "||", "validation", ".", "IsEmpty", "(", "value", ")", "{", "return", "true", "\n", "}", "\n", "// Accept and empty slice or map", "length", ",", "err", ":=", "validation", ".", "LengthOfValue", "(", "value", ")", "\n", "if", "err", "==", "nil", "&&", "length", "==", "0", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Returns", "true", "IFF", "value", "is", "zero", "value", "or", "has", "length", "0" ]

[ "func", "EnsureDir", "(", "dir", "string", ",", "mode", "os", ".", "FileMode", ")", "error", "{", "if", "fileOptions", ",", "err", ":=", "os", ".", "Stat", "(", "dir", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "if", "errMake", ":=", "os", ".", "MkdirAll", "(", "dir", ",", "mode", ")", ";", "errMake", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ",", "err", ")", "\n", "}", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ",", "err", ")", "\n", "}", "else", "if", "!", "fileOptions", ".", "IsDir", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Ensure", "the", "directory", "exists", "or", "create", "it", "if", "needed", "." ]

[ "func", "IsDir", "(", "directory", "string", ")", "bool", "{", "fileInfo", ",", "err", ":=", "os", ".", "Stat", "(", "directory", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "fileInfo", ".", "IsDir", "(", ")", "\n", "}" ]

[ "Check", "whether", "the", "provided", "directory", "exists" ]

[ "func", "(", "key", "*", "Key", ")", "MonaxKeysJSON", "(", ")", "string", "{", "jsonKey", ":=", "plainKeyJSON", "{", "Address", ":", "key", ".", "Address", ".", "String", "(", ")", ",", "Type", ":", "\"", "\"", ",", "PrivateKey", ":", "PrivateKeyplainKeyJSON", "{", "Plain", ":", "key", ".", "PrivateKey", "}", ",", "}", "\n", "bs", ",", "err", ":=", "json", ".", "Marshal", "(", "jsonKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", ".", "Error", "(", ")", "\n", "}", "\n", "return", "string", "(", "bs", ")", "\n", "}" ]

[ "Returns", "JSON", "string", "compatible", "with", "that", "stored", "by", "monax", "-", "keys" ]

[ "func", "NewSNativeContract", "(", "comment", ",", "name", "string", ",", "functions", "...", "*", "SNativeFunctionDescription", ")", "*", "SNativeContractDescription", "{", "functionsByID", ":=", "make", "(", "map", "[", "abi", ".", "FunctionID", "]", "*", "SNativeFunctionDescription", ",", "len", "(", "functions", ")", ")", "\n", "for", "_", ",", "f", ":=", "range", "functions", "{", "f", ".", "Abi", "=", "*", "abi", ".", "SpecFromStructReflect", "(", "f", ".", "Name", ",", "f", ".", "Arguments", ",", "f", ".", "Returns", ")", "\n", "fid", ":=", "f", ".", "Abi", ".", "FunctionID", "\n", "otherF", ",", "ok", ":=", "functionsByID", "[", "fid", "]", "\n", "if", "ok", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fid", ",", "otherF", ".", "Signature", "(", ")", ")", ")", "\n", "}", "\n", "functionsByID", "[", "fid", "]", "=", "f", "\n", "}", "\n", "return", "&", "SNativeContractDescription", "{", "Comment", ":", "comment", ",", "Name", ":", "name", ",", "functionsByID", ":", "functionsByID", ",", "functions", ":", "functions", ",", "}", "\n", "}" ]

[ "Create", "a", "new", "SNative", "contract", "description", "object", "by", "passing", "a", "comment", "name", "and", "a", "list", "of", "member", "functions", "descriptions" ]

[ "func", "(", "contract", "*", "SNativeContractDescription", ")", "Dispatch", "(", "st", "Interface", ",", "caller", "crypto", ".", "Address", ",", "args", "[", "]", "byte", ",", "gas", "*", "uint64", ",", "logger", "*", "logging", ".", "Logger", ")", "(", "output", "[", "]", "byte", ",", "err", "error", ")", "{", "logger", "=", "logger", ".", "With", "(", "structure", ".", "ScopeKey", ",", "\"", "\"", ",", "\"", "\"", ",", "contract", ".", "Name", ")", "\n\n", "if", "len", "(", "args", ")", "<", "abi", ".", "FunctionIDSize", "{", "return", "nil", ",", "errors", ".", "ErrorCodef", "(", "errors", ".", "ErrorCodeNativeFunction", ",", "\"", "\"", ",", "len", "(", "args", ")", ")", "\n", "}", "\n\n", "var", "id", "abi", ".", "FunctionID", "\n", "copy", "(", "id", "[", ":", "]", ",", "args", ")", "\n", "function", ",", "err", ":=", "contract", ".", "FunctionByID", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "logger", ".", "TraceMsg", "(", "\"", "\"", ",", "\"", "\"", ",", "caller", ",", "\"", "\"", ",", "function", ".", "Name", ")", "\n\n", "remainingArgs", ":=", "args", "[", "abi", ".", "FunctionIDSize", ":", "]", "\n\n", "// check if we have permission to call this function", "if", "!", "HasPermission", "(", "st", ",", "caller", ",", "function", ".", "PermFlag", ")", "{", "return", "nil", ",", "errors", ".", "LacksSNativePermission", "{", "Address", ":", "caller", ",", "SNative", ":", "function", ".", "Name", "}", "\n", "}", "\n\n", "nativeArgs", ":=", "reflect", ".", "New", "(", "function", ".", "Arguments", ")", ".", "Interface", "(", ")", "\n", "err", "=", "abi", ".", "UnpackIntoStruct", "(", "function", ".", "Abi", ".", "Inputs", ",", "remainingArgs", ",", "nativeArgs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "nativeRets", ",", "err", ":=", "function", ".", "F", "(", "st", ",", "caller", ",", "gas", ",", "logger", ",", "nativeArgs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "err", "=", "st", ".", "Error", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "function", ",", "err", ")", "\n", "}", "\n\n", "return", "abi", ".", "PackIntoStruct", "(", "function", ".", "Abi", ".", "Outputs", ",", "nativeRets", ")", "\n", "}" ]

[ "This", "function", "is", "designed", "to", "be", "called", "from", "the", "EVM", "once", "a", "SNative", "contract", "has", "been", "selected", ".", "It", "is", "also", "placed", "in", "a", "registry", "by", "registerSNativeContracts", "So", "it", "can", "be", "looked", "up", "by", "SNative", "address" ]

[ "func", "(", "contract", "*", "SNativeContractDescription", ")", "Address", "(", ")", "(", "address", "crypto", ".", "Address", ")", "{", "hash", ":=", "sha3", ".", "Sha3", "(", "[", "]", "byte", "(", "contract", ".", "Name", ")", ")", "\n", "copy", "(", "address", "[", ":", "]", ",", "hash", "[", "len", "(", "hash", ")", "-", "crypto", ".", "AddressLength", ":", "]", ")", "\n", "return", "\n", "}" ]

[ "We", "define", "the", "address", "of", "an", "SNative", "contact", "as", "the", "last", "20", "bytes", "of", "the", "sha3", "hash", "of", "its", "name" ]

[ "func", "(", "contract", "*", "SNativeContractDescription", ")", "FunctionByID", "(", "id", "abi", ".", "FunctionID", ")", "(", "*", "SNativeFunctionDescription", ",", "errors", ".", "CodedError", ")", "{", "f", ",", "ok", ":=", "contract", ".", "functionsByID", "[", "id", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "ErrorCodef", "(", "errors", ".", "ErrorCodeNativeFunction", ",", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "return", "f", ",", "nil", "\n", "}" ]

[ "Get", "function", "by", "calling", "identifier", "FunctionSelector" ]

[ "func", "(", "contract", "*", "SNativeContractDescription", ")", "FunctionByName", "(", "name", "string", ")", "(", "*", "SNativeFunctionDescription", ",", "error", ")", "{", "for", "_", ",", "f", ":=", "range", "contract", ".", "functions", "{", "if", "f", ".", "Name", "==", "name", "{", "return", "f", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}" ]

[ "Get", "function", "by", "name" ]

[ "func", "(", "contract", "*", "SNativeContractDescription", ")", "Functions", "(", ")", "[", "]", "*", "SNativeFunctionDescription", "{", "functions", ":=", "make", "(", "[", "]", "*", "SNativeFunctionDescription", ",", "len", "(", "contract", ".", "functions", ")", ")", "\n", "copy", "(", "functions", ",", "contract", ".", "functions", ")", "\n", "return", "functions", "\n", "}" ]

[ "Get", "functions", "in", "order", "of", "declaration" ]

[ "func", "(", "function", "*", "SNativeFunctionDescription", ")", "Signature", "(", ")", "string", "{", "argTypeNames", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "function", ".", "Abi", ".", "Inputs", ")", ")", "\n", "for", "i", ",", "arg", ":=", "range", "function", ".", "Abi", ".", "Inputs", "{", "argTypeNames", "[", "i", "]", "=", "arg", ".", "EVM", ".", "GetSignature", "(", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "function", ".", "Name", ",", "strings", ".", "Join", "(", "argTypeNames", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "SNative", "functions", "Get", "function", "signature" ]

[ "func", "(", "ct", "*", "CombinedTags", ")", "AddTags", "(", "concat", "bool", ",", "tagsList", "...", "Tagged", ")", "{", "for", "_", ",", "t", ":=", "range", "tagsList", "{", "for", "_", ",", "k", ":=", "range", "t", ".", "Keys", "(", ")", "{", "if", "len", "(", "ct", ".", "ks", "[", "k", "]", ")", "==", "0", "{", "ct", ".", "keys", "=", "append", "(", "ct", ".", "keys", ",", "k", ")", "\n", "// Store reference to key-holder amongst Taggeds", "ct", ".", "ks", "[", "k", "]", "=", "append", "(", "ct", ".", "ks", "[", "k", "]", ",", "t", ")", "\n", "}", "else", "if", "concat", "{", "// Store additional tag reference only if concat, otherwise first key-holder wins", "ct", ".", "ks", "[", "k", "]", "=", "append", "(", "ct", ".", "ks", "[", "k", "]", ",", "t", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Adds", "each", "of", "tagsList", "to", "CombinedTags", "-", "choosing", "whether", "values", "for", "the", "same", "key", "should", "be", "concatenated", "or", "whether", "the", "first", "should", "value", "should", "stick" ]

[ "func", "(", "cs", "*", "configSource", ")", "SetSkip", "(", "skip", "bool", ")", "ConfigProvider", "{", "return", "&", "configSource", "{", "skip", ":", "skip", ",", "from", ":", "cs", ".", "from", ",", "apply", ":", "cs", ".", "apply", ",", "}", "\n", "}" ]

[ "Returns", "a", "copy", "of", "the", "configSource", "with", "skip", "set", "as", "passed", "in" ]

[ "func", "XDGBaseDir", "(", "configFileName", "string", ")", "*", "configSource", "{", "skip", ":=", "false", "\n", "// Look for config in standard XDG specified locations", "configFile", ",", "err", ":=", "xdgbasedir", ".", "GetConfigFileLocation", "(", "configFileName", ")", "\n", "if", "err", "==", "nil", "{", "_", ",", "err", ":=", "os", ".", "Stat", "(", "configFile", ")", "\n", "// Skip if config file does not exist at default location", "skip", "=", "os", ".", "IsNotExist", "(", "err", ")", "\n", "}", "\n", "return", "&", "configSource", "{", "skip", ":", "skip", ",", "from", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ")", ",", "apply", ":", "func", "(", "baseConfig", "interface", "{", "}", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "FromFile", "(", "configFile", ",", "baseConfig", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "Try", "to", "find", "config", "by", "using", "XDG", "base", "dir", "spec" ]

[ "func", "Environment", "(", "key", "string", ")", "*", "configSource", "{", "configString", ":=", "os", ".", "Getenv", "(", "key", ")", "\n", "return", "&", "configSource", "{", "skip", ":", "configString", "==", "\"", "\"", ",", "from", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ")", ",", "apply", ":", "func", "(", "baseConfig", "interface", "{", "}", ")", "error", "{", "return", "FromString", "(", "configString", ",", "baseConfig", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "Source", "from", "a", "single", "environment", "variable", "with", "config", "embedded", "in", "JSON" ]

[ "func", "DeepCopy", "(", "conf", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "// Create a zero value", "confCopy", ":=", "reflect", ".", "New", "(", "reflect", ".", "TypeOf", "(", "conf", ")", ".", "Elem", "(", ")", ")", ".", "Interface", "(", ")", "\n", "// Perform a merge into that value to effect the copy", "err", ":=", "mergo", ".", "Merge", "(", "confCopy", ",", "conf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "confCopy", ",", "nil", "\n", "}" ]

[ "Passed", "a", "pointer", "to", "struct", "creates", "a", "deep", "copy", "of", "the", "struct" ]

[ "func", "NewProjectionFromBytes", "(", "bs", "[", "]", "byte", ")", "(", "*", "Projection", ",", "error", ")", "{", "eventSpec", ":=", "types", ".", "EventSpec", "{", "}", "\n\n", "err", ":=", "ValidateJSONEventSpec", "(", "bs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "json", ".", "Unmarshal", "(", "bs", ",", "&", "eventSpec", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "NewProjectionFromEventSpec", "(", "eventSpec", ")", "\n", "}" ]

[ "NewProjectionFromBytes", "creates", "a", "Projection", "from", "a", "stream", "of", "bytes" ]

[ "func", "NewProjectionFromFolder", "(", "specFileOrDirs", "...", "string", ")", "(", "*", "Projection", ",", "error", ")", "{", "eventSpec", ":=", "types", ".", "EventSpec", "{", "}", "\n\n", "const", "errHeader", "=", "\"", "\"", "\n\n", "for", "_", ",", "dir", ":=", "range", "specFileOrDirs", "{", "err", ":=", "filepath", ".", "Walk", "(", "dir", ",", "func", "(", "path", "string", ",", "_", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ",", "err", ")", "\n", "}", "\n", "if", "filepath", ".", "Ext", "(", "path", ")", "==", "\"", "\"", "{", "bs", ",", "err", ":=", "readFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "ValidateJSONEventSpec", "(", "bs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n\n", "fileEventSpec", ":=", "types", ".", "EventSpec", "{", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "bs", ",", "&", "fileEventSpec", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n\n", "eventSpec", "=", "append", "(", "eventSpec", ",", "fileEventSpec", "...", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "errHeader", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "NewProjectionFromEventSpec", "(", "eventSpec", ")", "\n", "}" ]

[ "NewProjectionFromFolder", "creates", "a", "Projection", "from", "a", "folder", "containing", "spec", "files" ]

[ "func", "NewProjectionFromEventSpec", "(", "eventSpec", "types", ".", "EventSpec", ")", "(", "*", "Projection", ",", "error", ")", "{", "// builds abi information from specification", "tables", ":=", "make", "(", "types", ".", "EventTables", ")", "\n\n", "// obtain global field mappings to add to table definitions", "globalFieldMappings", ":=", "getGlobalFieldMappings", "(", ")", "\n\n", "for", "_", ",", "eventClass", ":=", "range", "eventSpec", "{", "// validate json structure", "if", "err", ":=", "eventClass", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "eventClass", ",", "err", ")", "\n", "}", "\n\n", "// build columns mapping", "var", "columns", "[", "]", "*", "types", ".", "SQLTableColumn", "\n", "channels", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "string", ")", "\n\n", "// Add the global mappings", "eventClass", ".", "FieldMappings", "=", "append", "(", "globalFieldMappings", ",", "eventClass", ".", "FieldMappings", "...", ")", "\n\n", "i", ":=", "0", "\n", "for", "_", ",", "mapping", ":=", "range", "eventClass", ".", "FieldMappings", "{", "sqlType", ",", "sqlTypeLength", ",", "err", ":=", "getSQLType", "(", "mapping", ".", "Type", ",", "mapping", ".", "BytesToString", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "i", "++", "\n\n", "// Update channels broadcast payload subsets with this column", "for", "_", ",", "channel", ":=", "range", "mapping", ".", "Notify", "{", "channels", "[", "channel", "]", "=", "append", "(", "channels", "[", "channel", "]", ",", "mapping", ".", "ColumnName", ")", "\n", "}", "\n\n", "columns", "=", "append", "(", "columns", ",", "&", "types", ".", "SQLTableColumn", "{", "Name", ":", "mapping", ".", "ColumnName", ",", "Type", ":", "sqlType", ",", "Primary", ":", "mapping", ".", "Primary", ",", "Length", ":", "sqlTypeLength", ",", "}", ")", "\n", "}", "\n\n", "// Allow for compatible composition of tables", "var", "err", "error", "\n", "tables", "[", "eventClass", ".", "TableName", "]", ",", "err", "=", "mergeTables", "(", "tables", "[", "eventClass", ".", "TableName", "]", ",", "&", "types", ".", "SQLTable", "{", "Name", ":", "eventClass", ".", "TableName", ",", "NotifyChannels", ":", "channels", ",", "Columns", ":", "columns", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "}", "\n\n", "// check if there are duplicated duplicated column names (for a given table)", "colName", ":=", "make", "(", "map", "[", "string", "]", "int", ")", "\n\n", "for", "_", ",", "table", ":=", "range", "tables", "{", "for", "_", ",", "column", ":=", "range", "table", ".", "Columns", "{", "colName", "[", "table", ".", "Name", "+", "column", ".", "Name", "]", "++", "\n", "if", "colName", "[", "table", ".", "Name", "+", "column", ".", "Name", "]", ">", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "column", ".", "Name", ",", "table", ".", "Name", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "&", "Projection", "{", "Tables", ":", "tables", ",", "EventSpec", ":", "eventSpec", ",", "}", ",", "nil", "\n", "}" ]

[ "NewProjectionFromEventSpec", "receives", "a", "sqlsol", "event", "specification", "and", "returns", "a", "pointer", "to", "a", "filled", "projection", "structure", "that", "contains", "event", "types", "mapped", "to", "SQL", "column", "types", "and", "Event", "tables", "structures", "with", "table", "and", "columns", "info" ]

[ "func", "(", "p", "*", "Projection", ")", "GetColumn", "(", "tableName", ",", "columnName", "string", ")", "(", "*", "types", ".", "SQLTableColumn", ",", "error", ")", "{", "if", "table", ",", "ok", ":=", "p", ".", "Tables", "[", "tableName", "]", ";", "ok", "{", "column", ":=", "table", ".", "GetColumn", "(", "columnName", ")", "\n", "if", "column", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tableName", ",", "columnName", ")", "\n", "}", "\n", "return", "column", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tableName", ")", "\n", "}" ]

[ "Get", "the", "column", "for", "a", "particular", "table", "and", "column", "name" ]

[ "func", "readFile", "(", "file", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "theFile", ",", "err", ":=", "os", ".", "Open", "(", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "theFile", ".", "Close", "(", ")", "\n\n", "byteValue", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "theFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "byteValue", ",", "nil", "\n", "}" ]

[ "readFile", "opens", "a", "given", "file", "and", "reads", "it", "contents", "into", "a", "stream", "of", "bytes" ]

[ "func", "getSQLType", "(", "evmSignature", "string", ",", "bytesToString", "bool", ")", "(", "types", ".", "SQLColumnType", ",", "int", ",", "error", ")", "{", "evmSignature", "=", "strings", ".", "ToLower", "(", "evmSignature", ")", "\n", "re", ":=", "regexp", ".", "MustCompile", "(", "\"", "\"", ")", "\n", "typeSize", ",", "_", ":=", "strconv", ".", "Atoi", "(", "re", ".", "FindString", "(", "evmSignature", ")", ")", "\n\n", "switch", "{", "// solidity address => sql varchar", "case", "evmSignature", "==", "types", ".", "EventFieldTypeAddress", ":", "return", "types", ".", "SQLColumnTypeVarchar", ",", "40", ",", "nil", "\n", "// solidity bool => sql bool", "case", "evmSignature", "==", "types", ".", "EventFieldTypeBool", ":", "return", "types", ".", "SQLColumnTypeBool", ",", "0", ",", "nil", "\n", "// solidity bytes => sql bytes", "// bytesToString == true means there is a string in there so => sql varchar", "case", "strings", ".", "HasPrefix", "(", "evmSignature", ",", "types", ".", "EventFieldTypeBytes", ")", ":", "if", "bytesToString", "{", "return", "types", ".", "SQLColumnTypeVarchar", ",", "40", ",", "nil", "\n", "}", "else", "{", "return", "types", ".", "SQLColumnTypeByteA", ",", "0", ",", "nil", "\n", "}", "\n", "// solidity string => sql text", "case", "evmSignature", "==", "types", ".", "EventFieldTypeString", ":", "return", "types", ".", "SQLColumnTypeText", ",", "0", ",", "nil", "\n", "// solidity int or int256 => sql bigint", "// solidity int <= 32 => sql int", "// solidity int > 32 => sql numeric", "case", "strings", ".", "HasPrefix", "(", "evmSignature", ",", "types", ".", "EventFieldTypeInt", ")", ":", "if", "typeSize", "==", "0", "||", "typeSize", "==", "256", "{", "return", "types", ".", "SQLColumnTypeBigInt", ",", "0", ",", "nil", "\n", "}", "\n", "if", "typeSize", "<=", "32", "{", "return", "types", ".", "SQLColumnTypeInt", ",", "0", ",", "nil", "\n", "}", "else", "{", "return", "types", ".", "SQLColumnTypeNumeric", ",", "0", ",", "nil", "\n", "}", "\n", "// solidity uint or uint256 => sql bigint", "// solidity uint <= 16 => sql int", "// solidity uint > 16 => sql numeric", "case", "strings", ".", "HasPrefix", "(", "evmSignature", ",", "types", ".", "EventFieldTypeUInt", ")", ":", "if", "typeSize", "==", "0", "||", "typeSize", "==", "256", "{", "return", "types", ".", "SQLColumnTypeBigInt", ",", "0", ",", "nil", "\n", "}", "\n", "if", "typeSize", "<=", "16", "{", "return", "types", ".", "SQLColumnTypeInt", ",", "0", ",", "nil", "\n", "}", "else", "{", "return", "types", ".", "SQLColumnTypeNumeric", ",", "0", ",", "nil", "\n", "}", "\n", "default", ":", "return", "-", "1", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "evmSignature", ")", "\n", "}", "\n", "}" ]

[ "getSQLType", "maps", "event", "input", "types", "with", "corresponding", "SQL", "column", "types", "takes", "into", "account", "related", "solidity", "types", "info", "and", "element", "indexed", "or", "hashed" ]

[ "func", "getGlobalFieldMappings", "(", ")", "[", "]", "*", "types", ".", "EventFieldMapping", "{", "return", "[", "]", "*", "types", ".", "EventFieldMapping", "{", "{", "ColumnName", ":", "types", ".", "SQLColumnLabelHeight", ",", "Field", ":", "types", ".", "BlockHeightLabel", ",", "Type", ":", "types", ".", "EventFieldTypeString", ",", "}", ",", "{", "ColumnName", ":", "types", ".", "SQLColumnLabelTxHash", ",", "Field", ":", "types", ".", "TxTxHashLabel", ",", "Type", ":", "types", ".", "EventFieldTypeString", ",", "}", ",", "{", "ColumnName", ":", "types", ".", "SQLColumnLabelEventType", ",", "Field", ":", "types", ".", "EventTypeLabel", ",", "Type", ":", "types", ".", "EventFieldTypeString", ",", "}", ",", "{", "ColumnName", ":", "types", ".", "SQLColumnLabelEventName", ",", "Field", ":", "types", ".", "EventNameLabel", ",", "Type", ":", "types", ".", "EventFieldTypeString", ",", "}", ",", "}", "\n", "}" ]

[ "getGlobalColumns", "returns", "global", "columns", "for", "event", "table", "structures", "these", "columns", "will", "be", "part", "of", "every", "SQL", "event", "table", "to", "relate", "data", "with", "source", "events" ]

[ "func", "(", "acc", "*", "Account", ")", "Copy", "(", ")", "*", "Account", "{", "if", "acc", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "accCopy", ":=", "*", "acc", "\n", "accCopy", ".", "Permissions", ".", "Roles", "=", "make", "(", "[", "]", "string", ",", "len", "(", "acc", ".", "Permissions", ".", "Roles", ")", ")", "\n", "copy", "(", "accCopy", ".", "Permissions", ".", "Roles", ",", "acc", ".", "Permissions", ".", "Roles", ")", "\n", "return", "&", "accCopy", "\n", "}" ]

[ "Copies", "all", "mutable", "parts", "of", "account" ]

[ "func", "(", "gs", "*", "GenesisSpec", ")", "GenesisDoc", "(", "keyClient", "keys", ".", "KeyClient", ",", "generateNodeKeys", "bool", ")", "(", "*", "genesis", ".", "GenesisDoc", ",", "error", ")", "{", "genesisDoc", ":=", "new", "(", "genesis", ".", "GenesisDoc", ")", "\n", "if", "gs", ".", "GenesisTime", "==", "nil", "{", "genesisDoc", ".", "GenesisTime", "=", "time", ".", "Now", "(", ")", "\n", "}", "else", "{", "genesisDoc", ".", "GenesisTime", "=", "*", "gs", ".", "GenesisTime", "\n", "}", "\n\n", "if", "gs", ".", "ChainName", "==", "\"", "\"", "{", "genesisDoc", ".", "ChainName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "gs", ".", "ShortHash", "(", ")", ")", "\n", "}", "else", "{", "genesisDoc", ".", "ChainName", "=", "gs", ".", "ChainName", "\n", "}", "\n\n", "if", "gs", ".", "Params", ".", "ProposalThreshold", "!=", "0", "{", "genesisDoc", ".", "Params", ".", "ProposalThreshold", "=", "DefaultProposalThreshold", "\n", "}", "\n\n", "if", "len", "(", "gs", ".", "GlobalPermissions", ")", "==", "0", "{", "genesisDoc", ".", "GlobalPermissions", "=", "permission", ".", "DefaultAccountPermissions", ".", "Clone", "(", ")", "\n", "}", "else", "{", "basePerms", ",", "err", ":=", "permission", ".", "BasePermissionsFromStringList", "(", "gs", ".", "GlobalPermissions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "genesisDoc", ".", "GlobalPermissions", "=", "permission", ".", "AccountPermissions", "{", "Base", ":", "basePerms", ",", "}", "\n", "}", "\n\n", "templateAccounts", ":=", "gs", ".", "Accounts", "\n", "if", "len", "(", "gs", ".", "Accounts", ")", "==", "0", "{", "templateAccounts", "=", "append", "(", "templateAccounts", ",", "TemplateAccount", "{", "Amounts", ":", "balance", ".", "New", "(", ")", ".", "Power", "(", "DefaultPower", ")", ",", "}", ")", "\n", "}", "\n\n", "for", "i", ",", "templateAccount", ":=", "range", "templateAccounts", "{", "account", ",", "err", ":=", "templateAccount", ".", "GenesisAccount", "(", "keyClient", ",", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "genesisDoc", ".", "Accounts", "=", "append", "(", "genesisDoc", ".", "Accounts", ",", "*", "account", ")", "\n\n", "if", "templateAccount", ".", "Balances", "(", ")", ".", "HasPower", "(", ")", "{", "// Note this does not modify the input template", "templateAccount", ".", "Address", "=", "&", "account", ".", "Address", "\n", "validator", ",", "err", ":=", "templateAccount", ".", "Validator", "(", "keyClient", ",", "i", ",", "generateNodeKeys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "genesisDoc", ".", "Validators", "=", "append", "(", "genesisDoc", ".", "Validators", ",", "*", "validator", ")", "\n", "}", "\n", "}", "\n\n", "return", "genesisDoc", ",", "nil", "\n", "}" ]

[ "Produce", "a", "fully", "realised", "GenesisDoc", "from", "a", "template", "GenesisDoc", "that", "may", "omit", "values" ]

[ "func", "(", "vs", "*", "Set", ")", "SetPower", "(", "id", "crypto", ".", "PublicKey", ",", "power", "*", "big", ".", "Int", ")", "error", "{", "vs", ".", "ChangePower", "(", "id", ",", "power", ")", "\n", "return", "nil", "\n", "}" ]

[ "Implements", "Writer", "but", "will", "never", "error" ]

[ "func", "(", "vs", "*", "Set", ")", "ChangePower", "(", "id", "crypto", ".", "PublicKey", ",", "power", "*", "big", ".", "Int", ")", "*", "big", ".", "Int", "{", "address", ":=", "id", ".", "GetAddress", "(", ")", "\n", "// Calculate flow into this validator (positive means in, negative means out)", "flow", ":=", "vs", ".", "Flow", "(", "id", ",", "power", ")", "\n", "vs", ".", "totalPower", ".", "Add", "(", "vs", ".", "totalPower", ",", "flow", ")", "\n\n", "if", "vs", ".", "trim", "&&", "power", ".", "Sign", "(", ")", "==", "0", "{", "delete", "(", "vs", ".", "publicKeys", ",", "address", ")", "\n", "delete", "(", "vs", ".", "powers", ",", "address", ")", "\n", "}", "else", "{", "vs", ".", "publicKeys", "[", "address", "]", "=", "crypto", ".", "NewAddressable", "(", "id", ")", "\n", "vs", ".", "powers", "[", "address", "]", "=", "new", "(", "big", ".", "Int", ")", ".", "Set", "(", "power", ")", "\n", "}", "\n", "return", "flow", "\n", "}" ]

[ "Add", "the", "power", "of", "a", "validator", "and", "returns", "the", "flow", "into", "that", "validator" ]

[ "func", "(", "vs", "*", "Set", ")", "Flow", "(", "id", "crypto", ".", "PublicKey", ",", "power", "*", "big", ".", "Int", ")", "*", "big", ".", "Int", "{", "return", "new", "(", "big", ".", "Int", ")", ".", "Sub", "(", "power", ",", "vs", ".", "GetPower", "(", "id", ".", "GetAddress", "(", ")", ")", ")", "\n", "}" ]

[ "Returns", "the", "flow", "that", "would", "be", "induced", "by", "a", "validator", "power", "change" ]

[ "func", "(", "vs", "*", "Set", ")", "MaybePower", "(", "id", "crypto", ".", "Address", ")", "*", "big", ".", "Int", "{", "if", "vs", ".", "powers", "[", "id", "]", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "new", "(", "big", ".", "Int", ")", ".", "Set", "(", "vs", ".", "powers", "[", "id", "]", ")", "\n", "}" ]

[ "Returns", "the", "power", "of", "id", "but", "only", "if", "it", "is", "set" ]

[ "func", "(", "vs", "*", "Set", ")", "Power", "(", "id", "crypto", ".", "Address", ")", "(", "*", "big", ".", "Int", ",", "error", ")", "{", "return", "vs", ".", "GetPower", "(", "id", ")", ",", "nil", "\n", "}" ]

[ "Version", "of", "Power", "to", "match", "interface" ]

[ "func", "(", "vs", "*", "Set", ")", "Equal", "(", "vsOther", "*", "Set", ")", "error", "{", "if", "vs", ".", "Size", "(", ")", "!=", "vsOther", ".", "Size", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "vs", ".", "Size", "(", ")", ",", "vsOther", ".", "Size", "(", ")", ")", "\n", "}", "\n", "// Stop iteration IFF we find a non-matching validator", "return", "vs", ".", "IterateValidators", "(", "func", "(", "id", "crypto", ".", "Addressable", ",", "power", "*", "big", ".", "Int", ")", "error", "{", "otherPower", ":=", "vsOther", ".", "GetPower", "(", "id", ".", "GetAddress", "(", ")", ")", "\n", "if", "otherPower", ".", "Cmp", "(", "power", ")", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "power", ",", "otherPower", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "Returns", "an", "error", "if", "the", "Sets", "are", "not", "equal", "describing", "which", "part", "of", "their", "structures", "differ" ]

[ "func", "(", "vs", "*", "Set", ")", "IterateValidators", "(", "iter", "func", "(", "id", "crypto", ".", "Addressable", ",", "power", "*", "big", ".", "Int", ")", "error", ")", "error", "{", "if", "vs", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "addresses", ":=", "make", "(", "crypto", ".", "Addresses", ",", "0", ",", "len", "(", "vs", ".", "powers", ")", ")", "\n", "for", "address", ":=", "range", "vs", ".", "powers", "{", "addresses", "=", "append", "(", "addresses", ",", "address", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "addresses", ")", "\n", "for", "_", ",", "address", ":=", "range", "addresses", "{", "err", ":=", "iter", "(", "vs", ".", "publicKeys", "[", "address", "]", ",", "new", "(", "big", ".", "Int", ")", ".", "Set", "(", "vs", ".", "powers", "[", "address", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Iterates", "over", "validators", "sorted", "by", "address" ]

[ "func", "(", "br", "*", "BlockRange", ")", "Bounds", "(", "latestBlockHeight", "uint64", ")", "(", "startHeight", ",", "endHeight", "uint64", ",", "streaming", "bool", ")", "{", "// End bound is exclusive in state.GetEvents so we increment the height", "return", "br", ".", "GetStart", "(", ")", ".", "Bound", "(", "latestBlockHeight", ")", ",", "br", ".", "GetEnd", "(", ")", ".", "Bound", "(", "latestBlockHeight", ")", "+", "1", ",", "br", ".", "GetEnd", "(", ")", ".", "GetType", "(", ")", "==", "Bound_STREAM", "\n", "}" ]

[ "Get", "bounds", "suitable", "for", "events", ".", "Provider" ]

[ "func", "NewRPCRequest", "(", "id", "string", ",", "method", "string", ",", "params", "json", ".", "RawMessage", ")", "*", "RPCRequest", "{", "return", "&", "RPCRequest", "{", "JSONRPC", ":", "\"", "\"", ",", "Id", ":", "id", ",", "Method", ":", "method", ",", "Params", ":", "params", ",", "}", "\n", "}" ]

[ "Create", "a", "new", "RPC", "request", ".", "This", "is", "the", "generic", "struct", "that", "is", "passed", "to", "RPC", "methods" ]

[ "func", "NewRPCResponse", "(", "id", "string", ",", "res", "interface", "{", "}", ")", "RPCResponse", "{", "return", "RPCResponse", "(", "&", "RPCResultResponse", "{", "Result", ":", "res", ",", "Id", ":", "id", ",", "JSONRPC", ":", "\"", "\"", ",", "}", ")", "\n", "}" ]

[ "NewRPCResponse", "creates", "a", "new", "response", "object", "from", "a", "result" ]

[ "func", "NewRPCErrorResponse", "(", "id", "string", ",", "code", "int", ",", "message", "string", ")", "RPCResponse", "{", "return", "RPCResponse", "(", "&", "RPCErrorResponse", "{", "Error", ":", "&", "RPCError", "{", "code", ",", "message", "}", ",", "Id", ":", "id", ",", "JSONRPC", ":", "\"", "\"", ",", "}", ")", "\n", "}" ]

[ "NewRPCErrorResponse", "creates", "a", "new", "error", "-", "response", "object", "from", "the", "error", "code", "and", "message" ]

[ "func", "NewMultiIterator", "(", "reverse", "bool", ",", "iterators", "...", "KVIterator", ")", "*", "MultiIterator", "{", "// reuse backing array", "lessComp", ":=", "-", "1", "\n", "if", "reverse", "{", "lessComp", "=", "1", "\n", "}", "\n", "mi", ":=", "&", "MultiIterator", "{", "iterators", ":", "iterators", ",", "iteratorOrder", ":", "make", "(", "map", "[", "KVIterator", "]", "int", ")", ",", "lessComp", ":", "lessComp", ",", "}", "\n", "mi", ".", "init", "(", ")", "\n", "return", "mi", "\n", "}" ]

[ "MultiIterator", "iterates", "in", "order", "over", "a", "series", "o" ]

[ "func", "InitKeyClient", "(", "keysUrl", "string", ")", "(", "*", "LocalKeyClient", ",", "error", ")", "{", "aliveCh", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "localKeyClient", ",", "err", ":=", "keys", ".", "NewRemoteKeyClient", "(", "keysUrl", ",", "logging", ".", "NewNoopLogger", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "localKeyClient", ".", "HealthCheck", "(", ")", "\n\n", "go", "func", "(", ")", "{", "for", "err", "!=", "nil", "{", "err", "=", "localKeyClient", ".", "HealthCheck", "(", ")", "\n", "}", "\n", "aliveCh", "<-", "struct", "{", "}", "{", "}", "\n", "}", "(", ")", "\n", "select", "{", "case", "<-", "time", ".", "After", "(", "keysTimeout", ")", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keysTimeout", ",", "err", ")", "\n", "case", "<-", "aliveCh", ":", "return", "&", "LocalKeyClient", "{", "localKeyClient", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "Returns", "an", "initialized", "key", "client", "to", "a", "docker", "container", "running", "the", "keys", "server", "Adding", "the", "Ip", "address", "is", "optional", "and", "should", "only", "be", "used", "for", "passing", "data" ]

[ "func", "NormaliseDomain", "(", "low", ",", "high", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "[", "]", "byte", ")", "{", "if", "len", "(", "low", ")", "==", "0", "{", "low", "=", "[", "]", "byte", "{", "}", "\n", "}", "\n", "return", "low", ",", "high", "\n", "}" ]

[ "NormaliseDomain", "encodes", "the", "assumption", "that", "when", "nil", "is", "used", "as", "a", "lower", "bound", "is", "interpreted", "as", "low", "rather", "than", "high" ]