Datasets:

CM

/

codexglue_code2text_go

like 0

[ "func", "(", "r", "*", "Router", ")", "Post", "(", "path", "string", ",", "fn", "interface", "{", "}", ")", "*", "Router", "{", "return", "r", ".", "addRoute", "(", "httpMethodPost", ",", "path", ",", "fn", ")", "\n", "}" ]

[ "Post", "will", "add", "a", "route", "to", "the", "router", "that", "matches", "on", "POST", "requests", "and", "the", "specified", "path", "." ]

[ "func", "(", "r", "*", "Router", ")", "Put", "(", "path", "string", ",", "fn", "interface", "{", "}", ")", "*", "Router", "{", "return", "r", ".", "addRoute", "(", "httpMethodPut", ",", "path", ",", "fn", ")", "\n", "}" ]

[ "Put", "will", "add", "a", "route", "to", "the", "router", "that", "matches", "on", "PUT", "requests", "and", "the", "specified", "path", "." ]

[ "func", "(", "r", "*", "Router", ")", "Delete", "(", "path", "string", ",", "fn", "interface", "{", "}", ")", "*", "Router", "{", "return", "r", ".", "addRoute", "(", "httpMethodDelete", ",", "path", ",", "fn", ")", "\n", "}" ]

[ "Delete", "will", "add", "a", "route", "to", "the", "router", "that", "matches", "on", "DELETE", "requests", "and", "the", "specified", "path", "." ]

[ "func", "(", "r", "*", "Router", ")", "Patch", "(", "path", "string", ",", "fn", "interface", "{", "}", ")", "*", "Router", "{", "return", "r", ".", "addRoute", "(", "httpMethodPatch", ",", "path", ",", "fn", ")", "\n", "}" ]

[ "Patch", "will", "add", "a", "route", "to", "the", "router", "that", "matches", "on", "PATCH", "requests", "and", "the", "specified", "path", "." ]

[ "func", "(", "r", "*", "Router", ")", "Head", "(", "path", "string", ",", "fn", "interface", "{", "}", ")", "*", "Router", "{", "return", "r", ".", "addRoute", "(", "httpMethodHead", ",", "path", ",", "fn", ")", "\n", "}" ]

[ "Head", "will", "add", "a", "route", "to", "the", "router", "that", "matches", "on", "HEAD", "requests", "and", "the", "specified", "path", "." ]

[ "func", "(", "r", "*", "Router", ")", "Options", "(", "path", "string", ",", "fn", "interface", "{", "}", ")", "*", "Router", "{", "return", "r", ".", "addRoute", "(", "httpMethodOptions", ",", "path", ",", "fn", ")", "\n", "}" ]

[ "Options", "will", "add", "a", "route", "to", "the", "router", "that", "matches", "on", "OPTIONS", "requests", "and", "the", "specified", "path", "." ]

[ "func", "(", "r", "*", "Router", ")", "depth", "(", ")", "int", "{", "max", ":=", "0", "\n", "for", "_", ",", "child", ":=", "range", "r", ".", "children", "{", "childDepth", ":=", "child", ".", "depth", "(", ")", "\n", "if", "childDepth", ">", "max", "{", "max", "=", "childDepth", "\n", "}", "\n", "}", "\n", "return", "max", "+", "1", "\n", "}" ]

[ "Calculates", "the", "max", "child", "depth", "of", "the", "node", ".", "Leaves", "return", "1", ".", "For", "Parent", "-", ">", "Child", "Parent", "is", "2", "." ]

[ "func", "(", "rootRouter", "*", "Router", ")", "ServeHTTP", "(", "rw", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "// Manually create a closure. These variables are needed in middlewareStack.", "// The reason we put these here instead of in the middleware stack, is Go (as of 1.2)", "// creates a heap variable for each varaiable in the closure. To minimize that, we'll", "// just have one (closure *middlewareClosure).", "var", "closure", "middlewareClosure", "\n", "closure", ".", "Request", ".", "Request", "=", "r", "\n", "closure", ".", "appResponseWriter", ".", "ResponseWriter", "=", "rw", "\n", "closure", ".", "Routers", "=", "make", "(", "[", "]", "*", "Router", ",", "1", ",", "rootRouter", ".", "maxChildrenDepth", ")", "\n", "closure", ".", "Routers", "[", "0", "]", "=", "rootRouter", "\n", "closure", ".", "Contexts", "=", "make", "(", "[", "]", "reflect", ".", "Value", ",", "1", ",", "rootRouter", ".", "maxChildrenDepth", ")", "\n", "closure", ".", "Contexts", "[", "0", "]", "=", "reflect", ".", "New", "(", "rootRouter", ".", "contextType", ")", "\n", "closure", ".", "currentMiddlewareLen", "=", "len", "(", "rootRouter", ".", "middleware", ")", "\n", "closure", ".", "RootRouter", "=", "rootRouter", "\n", "closure", ".", "Request", ".", "rootContext", "=", "closure", ".", "Contexts", "[", "0", "]", "\n\n", "// Handle errors", "defer", "func", "(", ")", "{", "if", "recovered", ":=", "recover", "(", ")", ";", "recovered", "!=", "nil", "{", "rootRouter", ".", "handlePanic", "(", "&", "closure", ".", "appResponseWriter", ",", "&", "closure", ".", "Request", ",", "recovered", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "next", ":=", "middlewareStack", "(", "&", "closure", ")", "\n", "next", "(", "&", "closure", ".", "appResponseWriter", ",", "&", "closure", ".", "Request", ")", "\n", "}" ]

[ "This", "is", "the", "entry", "point", "for", "servering", "all", "requests", "." ]

[ "func", "ShowErrorsMiddleware", "(", "rw", "ResponseWriter", ",", "req", "*", "Request", ",", "next", "NextMiddlewareFunc", ")", "{", "defer", "func", "(", ")", "{", "if", "err", ":=", "recover", "(", ")", ";", "err", "!=", "nil", "{", "const", "size", "=", "4096", "\n", "stack", ":=", "make", "(", "[", "]", "byte", ",", "size", ")", "\n", "stack", "=", "stack", "[", ":", "runtime", ".", "Stack", "(", "stack", ",", "false", ")", "]", "\n\n", "renderPrettyError", "(", "rw", ",", "req", ",", "err", ",", "stack", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "next", "(", "rw", ",", "req", ")", "\n", "}" ]

[ "ShowErrorsMiddleware", "will", "catch", "panics", "and", "render", "an", "HTML", "page", "with", "the", "stack", "trace", ".", "This", "middleware", "should", "only", "be", "used", "in", "development", "." ]

[ "func", "WithLevels", "(", "levels", "...", "logrus", ".", "Level", ")", "OptionFunc", "{", "return", "func", "(", "h", "*", "Hook", ")", "{", "h", ".", "triggers", "=", "levels", "\n", "}", "\n", "}" ]

[ "WithLevels", "is", "an", "OptionFunc", "that", "customizes", "the", "log", ".", "Levels", "the", "hook", "will", "report", "on", "." ]

[ "func", "WithMinLevel", "(", "level", "logrus", ".", "Level", ")", "OptionFunc", "{", "var", "levels", "[", "]", "logrus", ".", "Level", "\n", "for", "_", ",", "l", ":=", "range", "logrus", ".", "AllLevels", "{", "if", "l", "<=", "level", "{", "levels", "=", "append", "(", "levels", ",", "l", ")", "\n", "}", "\n", "}", "\n\n", "return", "func", "(", "h", "*", "Hook", ")", "{", "h", ".", "triggers", "=", "levels", "\n", "}", "\n", "}" ]

[ "WithMinLevel", "is", "an", "OptionFunc", "that", "customizes", "the", "log", ".", "Levels", "the", "hook", "will", "report", "on", "by", "selecting", "all", "levels", "more", "severe", "than", "the", "one", "provided", "." ]

[ "func", "NewHook", "(", "token", "string", ",", "env", "string", ",", "opts", "...", "OptionFunc", ")", "*", "Hook", "{", "h", ":=", "NewHookForLevels", "(", "token", ",", "env", ",", "defaultTriggerLevels", ")", "\n\n", "for", "_", ",", "o", ":=", "range", "opts", "{", "o", "(", "h", ")", "\n", "}", "\n\n", "return", "h", "\n", "}" ]

[ "NewHook", "creates", "a", "hook", "that", "is", "intended", "for", "use", "with", "your", "own", "logrus", ".", "Logger", "instance", ".", "Uses", "the", "defualt", "report", "levels", "defined", "in", "wellKnownErrorFields", "." ]

[ "func", "NewHookForLevels", "(", "token", "string", ",", "env", "string", ",", "levels", "[", "]", "logrus", ".", "Level", ")", "*", "Hook", "{", "return", "&", "Hook", "{", "Client", ":", "roll", ".", "New", "(", "token", ",", "env", ")", ",", "triggers", ":", "levels", ",", "ignoredErrors", ":", "make", "(", "[", "]", "error", ",", "0", ")", ",", "ignoreErrorFunc", ":", "func", "(", "error", ")", "bool", "{", "return", "false", "}", ",", "ignoreFunc", ":", "func", "(", "error", ",", "map", "[", "string", "]", "string", ")", "bool", "{", "return", "false", "}", ",", "}", "\n", "}" ]

[ "NewHookForLevels", "provided", "by", "the", "caller", ".", "Otherwise", "works", "like", "NewHook", "." ]

[ "func", "SetupLoggingForLevels", "(", "token", ",", "env", "string", ",", "levels", "[", "]", "logrus", ".", "Level", ")", "{", "setupLogging", "(", "token", ",", "env", ",", "levels", ")", "\n", "}" ]

[ "SetupLoggingForLevels", "works", "like", "SetupLogging", "but", "allows", "you", "to", "set", "the", "levels", "on", "which", "to", "trigger", "this", "hook", "." ]

[ "func", "(", "r", "*", "Hook", ")", "ReportPanic", "(", ")", "{", "if", "p", ":=", "recover", "(", ")", ";", "p", "!=", "nil", "{", "if", "_", ",", "err", ":=", "r", ".", "Client", ".", "Critical", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ")", ",", "nil", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n", "panic", "(", "p", ")", "\n", "}", "\n", "}" ]

[ "ReportPanic", "attempts", "to", "report", "the", "panic", "to", "rollbar", "using", "the", "provided", "client", "and", "then", "re", "-", "panic", ".", "If", "it", "can", "t", "report", "the", "panic", "it", "will", "print", "an", "error", "to", "stderr", "." ]

[ "func", "ReportPanic", "(", "token", ",", "env", "string", ")", "{", "if", "token", "!=", "\"", "\"", "{", "h", ":=", "&", "Hook", "{", "Client", ":", "roll", ".", "New", "(", "token", ",", "env", ")", "}", "\n", "h", ".", "ReportPanic", "(", ")", "\n", "}", "\n", "}" ]

[ "ReportPanic", "attempts", "to", "report", "the", "panic", "to", "rollbar", "if", "the", "token", "is", "set" ]

[ "func", "(", "r", "*", "Hook", ")", "Levels", "(", ")", "[", "]", "logrus", ".", "Level", "{", "if", "r", ".", "triggers", "==", "nil", "{", "return", "defaultTriggerLevels", "\n", "}", "\n", "return", "r", ".", "triggers", "\n", "}" ]

[ "Levels", "returns", "the", "logrus", "log", ".", "Levels", "that", "this", "hook", "handles" ]

[ "func", "extractError", "(", "entry", "*", "logrus", ".", "Entry", ")", "(", "[", "]", "uintptr", ",", "error", ")", "{", "var", "trace", "[", "]", "uintptr", "\n", "fields", ":=", "entry", ".", "Data", "\n\n", "type", "stackTracer", "interface", "{", "StackTrace", "(", ")", "errors", ".", "StackTrace", "\n", "}", "\n\n", "for", "_", ",", "f", ":=", "range", "wellKnownErrorFields", "{", "e", ",", "ok", ":=", "fields", "[", "f", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "err", ",", "ok", ":=", "e", ".", "(", "error", ")", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n\n", "cause", ":=", "errors", ".", "Cause", "(", "err", ")", "\n", "tracer", ",", "ok", ":=", "err", ".", "(", "stackTracer", ")", "\n", "if", "ok", "{", "return", "copyStackTrace", "(", "tracer", ".", "StackTrace", "(", ")", ")", ",", "cause", "\n", "}", "\n", "return", "trace", ",", "cause", "\n", "}", "\n\n", "// when no error found, default to the logged message.", "return", "trace", ",", "fmt", ".", "Errorf", "(", "entry", ".", "Message", ")", "\n", "}" ]

[ "extractError", "attempts", "to", "extract", "an", "error", "from", "a", "well", "known", "field", "err", "or", "error" ]

[ "func", "(", "d", "*", "Detector", ")", "merge", "(", "detectedRegions", "Regions", ",", "mergeRegions", "[", "]", "[", "]", "int", ")", "{", "var", "newDetectedRegions", "Regions", "\n\n", "// merging detected regions", "for", "index", ",", "region", ":=", "range", "mergeRegions", "{", "if", "len", "(", "newDetectedRegions", ")", ">=", "index", "{", "newDetectedRegions", "=", "append", "(", "newDetectedRegions", ",", "Region", "{", "}", ")", "\n", "}", "\n", "for", "_", ",", "r", ":=", "range", "region", "{", "newDetectedRegions", "[", "index", "]", "=", "append", "(", "newDetectedRegions", "[", "index", "]", ",", "detectedRegions", "[", "r", "]", "...", ")", "\n", "detectedRegions", "[", "r", "]", "=", "Region", "{", "}", "\n", "}", "\n", "}", "\n\n", "// push the rest of the regions to the newDetectedRegions array", "// (regions without merging)", "for", "_", ",", "region", ":=", "range", "detectedRegions", "{", "if", "len", "(", "region", ")", ">", "0", "{", "newDetectedRegions", "=", "append", "(", "newDetectedRegions", ",", "region", ")", "\n", "}", "\n", "}", "\n\n", "// clean up", "d", ".", "clearRegions", "(", "newDetectedRegions", ")", "\n", "}" ]

[ "function", "for", "merging", "detected", "regions" ]

[ "func", "(", "d", "*", "Detector", ")", "clearRegions", "(", "detectedRegions", "Regions", ")", "{", "for", "_", ",", "region", ":=", "range", "detectedRegions", "{", "if", "len", "(", "region", ")", ">", "30", "{", "d", ".", "SkinRegions", "=", "append", "(", "d", ".", "SkinRegions", ",", "region", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "clean", "up", "function", "only", "push", "regions", "which", "are", "bigger", "than", "a", "specific", "amount", "to", "the", "final", "resul" ]

[ "func", "classifySkin", "(", "r", ",", "g", ",", "b", "uint32", ")", "(", "bool", ",", "float64", ")", "{", "rgbClassifier", ":=", "r", ">", "95", "&&", "g", ">", "40", "&&", "g", "<", "100", "&&", "b", ">", "20", "&&", "maxRgb", "(", "r", ",", "g", ",", "b", ")", "-", "minRgb", "(", "r", ",", "g", ",", "b", ")", ">", "15", "&&", "math", ".", "Abs", "(", "float64", "(", "r", "-", "g", ")", ")", ">", "15", "&&", "r", ">", "g", "&&", "r", ">", "b", "\n\n", "nr", ",", "ng", ",", "_", ":=", "toNormalizedRgb", "(", "r", ",", "g", ",", "b", ")", "\n", "normalizedRgbClassifier", ":=", "nr", "/", "ng", ">", "1.185", "&&", "(", "float64", "(", "r", "*", "b", ")", ")", "/", "math", ".", "Pow", "(", "float64", "(", "r", "+", "g", "+", "b", ")", ",", "2", ")", ">", "0.107", "&&", "(", "float64", "(", "r", "*", "g", ")", ")", "/", "math", ".", "Pow", "(", "float64", "(", "r", "+", "g", "+", "b", ")", ",", "2", ")", ">", "0.112", "\n\n", "h", ",", "s", ",", "v", ":=", "toHsv", "(", "r", ",", "g", ",", "b", ")", "\n", "hsvClassifier", ":=", "h", ">", "0", "&&", "h", "<", "35", "&&", "s", ">", "0.23", "&&", "s", "<", "0.68", "\n\n", "// ycc doesnt work", "result", ":=", "rgbClassifier", "||", "normalizedRgbClassifier", "||", "hsvClassifier", "\n", "return", "result", ",", "v", "\n", "}" ]

[ "A", "Survey", "on", "Pixel", "-", "Based", "Skin", "Color", "Detection", "Techniques" ]

[ "func", "Mask", "(", "dest", "Trits", ",", "message", "Trits", ",", "length", "uint64", ",", "c", "*", "curl", ".", "Curl", ")", "{", "var", "chunkLength", "uint64", "\n\n", "chunk", ":=", "make", "(", "Trits", ",", "HashTrinarySize", ")", "\n\n", "for", "i", ":=", "uint64", "(", "0", ")", ";", "i", "<", "length", ";", "i", "+=", "HashTrinarySize", "{", "if", "length", "-", "i", "<", "HashTrinarySize", "{", "chunkLength", "=", "length", "-", "i", "\n", "}", "else", "{", "chunkLength", "=", "HashTrinarySize", "\n", "}", "\n\n", "copy", "(", "chunk", ",", "message", "[", "i", ":", "i", "+", "chunkLength", "]", ")", "\n\n", "for", "j", ":=", "uint64", "(", "0", ")", ";", "j", "<", "chunkLength", ";", "j", "++", "{", "dest", "[", "i", "+", "j", "]", "=", "Sum", "(", "chunk", "[", "j", "]", ",", "c", ".", "State", "[", "j", "]", ")", "\n", "}", "\n", "c", ".", "Absorb", "(", "chunk", "[", ":", "chunkLength", "]", ")", "\n", "}", "\n", "}" ]

[ "Masks", "a", "given", "message", "with", "a", "curl", "instance", "state", ".", "dest", "is", "the", "destination", "of", "the", "masked", "message", "message", "is", "the", "message", "to", "be", "masked", "length", "is", "the", "length", "of", "the", "message", "c", "is", "the", "curl", "instance", "used", "to", "mask", "the", "message" ]

[ "func", "Unmask", "(", "cipher", "Trits", ",", "length", "uint64", ",", "c", "*", "curl", ".", "Curl", ")", "(", "dest", "Trits", ")", "{", "var", "chunkLength", "uint64", "\n", "dest", "=", "make", "(", "Trits", ",", "length", ")", "\n\n", "for", "i", ":=", "uint64", "(", "0", ")", ";", "i", "<", "length", ";", "i", "+=", "HashTrinarySize", "{", "if", "length", "-", "i", "<", "HashTrinarySize", "{", "chunkLength", "=", "length", "-", "i", "\n", "}", "else", "{", "chunkLength", "=", "HashTrinarySize", "\n", "}", "\n\n", "for", "j", ":=", "uint64", "(", "0", ")", ";", "j", "<", "chunkLength", ";", "j", "++", "{", "dest", "[", "i", "+", "j", "]", "=", "Sum", "(", "cipher", "[", "i", "+", "j", "]", ",", "-", "c", ".", "State", "[", "j", "]", ")", "\n", "}", "\n", "c", ".", "Absorb", "(", "dest", "[", "i", ":", "i", "+", "chunkLength", "]", ")", "\n", "}", "\n", "return", "dest", "\n", "}" ]

[ "Unmasks", "a", "given", "cipher", "with", "a", "curl", "instance", "state", ".", "cipher", "is", "the", "cipher", "to", "be", "unmasked", "length", "is", "the", "length", "of", "the", "cipher", "c", "is", "the", "curl", "instance", "used", "to", "unmask", "the", "cipher", "returns", "the", "unmasked", "cipher" ]

[ "func", "ComposeAPI", "(", "settings", "Settings", ",", "createProvider", "...", "CreateProviderFunc", ")", "(", "*", "API", ",", "error", ")", "{", "if", "settings", "==", "nil", "{", "return", "nil", ",", "ErrSettingsNil", "\n", "}", "\n", "var", "provider", "Provider", "\n", "var", "err", "error", "\n", "if", "len", "(", "createProvider", ")", ">", "0", "&&", "createProvider", "[", "0", "]", "!=", "nil", "{", "provider", ",", "err", "=", "createProvider", "[", "0", "]", "(", "settings", ")", "\n", "}", "else", "{", "provider", ",", "err", "=", "NewHTTPClient", "(", "settings", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "api", ":=", "&", "API", "{", "provider", ":", "provider", "}", "\n", "if", "settings", ".", "ProofOfWorkFunc", "(", ")", "!=", "nil", "{", "api", ".", "localProofOfWorkFunc", "=", "settings", ".", "ProofOfWorkFunc", "(", ")", "\n", "}", "\n\n", "return", "api", ",", "nil", "\n", "}" ]

[ "ComposeAPI", "composes", "a", "new", "API", "from", "the", "given", "settings", "and", "provider", ".", "If", "no", "provider", "function", "is", "supplied", "then", "the", "default", "http", "provider", "is", "used", ".", "Settings", "must", "not", "be", "nil", "." ]

[ "func", "Validate", "(", "validators", "...", "Validatable", ")", "error", "{", "for", "i", ":=", "range", "validators", "{", "if", "err", ":=", "validators", "[", "i", "]", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "calls", "all", "given", "validators", "or", "returns", "the", "first", "occurred", "error", "." ]

[ "func", "ValidateNonEmptyStrings", "(", "err", "error", ",", "slice", "...", "string", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "if", "slice", "==", "nil", "||", "len", "(", "slice", ")", "==", "0", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateNonEmptyStrings", "checks", "for", "non", "empty", "string", "slices", "." ]

[ "func", "ValidateTransactionHashes", "(", "hashes", "...", "Hash", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "for", "i", ":=", "range", "hashes", "{", "if", "!", "IsTransactionHash", "(", "hashes", "[", "i", "]", ")", "{", "return", "errors", ".", "Wrapf", "(", "ErrInvalidTransactionHash", ",", "\"", "\"", ",", "hashes", "[", "i", "]", ",", "i", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateTransactionHashes", "validates", "the", "given", "transaction", "hashes", "." ]

[ "func", "ValidateHashes", "(", "hashes", "...", "Hash", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "for", "i", ":=", "range", "hashes", "{", "if", "!", "IsHash", "(", "hashes", "[", "i", "]", ")", "{", "return", "errors", ".", "Wrapf", "(", "ErrInvalidHash", ",", "\"", "\"", ",", "hashes", "[", "i", "]", ",", "i", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateHashes", "validates", "the", "given", "hashes", "." ]

[ "func", "ValidateAddresses", "(", "checkLastTrit", "bool", ",", "addrs", "...", "Hash", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "for", "i", ":=", "range", "addrs", "{", "if", "!", "IsAddressWithChecksum", "(", "addrs", "[", "i", "]", ")", "{", "return", "errors", ".", "Wrapf", "(", "ErrInvalidHash", ",", "\"", "\"", ",", "addrs", "[", "i", "]", ",", "i", ")", "\n", "}", "\n", "if", "checkLastTrit", "{", "lastTrits", ":=", "MustTrytesToTrits", "(", "string", "(", "addrs", "[", "i", "]", "[", "80", "]", ")", ")", "\n", "if", "lastTrits", "[", "2", "]", "!=", "0", "{", "return", "errors", ".", "Wrapf", "(", "ErrInvalidHash", ",", "\"", "\"", ",", "addrs", "[", "i", "]", ",", "i", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateAddresses", "validates", "the", "given", "addresses", "which", "must", "include", "the", "checksum", "." ]

[ "func", "ValidateTransactionTrytes", "(", "trytes", "...", "Trytes", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "for", "i", ":=", "range", "trytes", "{", "if", "!", "IsTransactionTrytes", "(", "trytes", "[", "i", "]", ")", "{", "return", "errors", ".", "Wrapf", "(", "ErrInvalidTransactionTrytes", ",", "\"", "\"", ",", "i", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateTransactionTrytes", "validates", "the", "given", "transaction", "trytes", "." ]

[ "func", "ValidateAttachedTransactionTrytes", "(", "trytes", "...", "Trytes", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "for", "i", ":=", "range", "trytes", "{", "if", "!", "IsAttachedTrytes", "(", "trytes", "[", "i", "]", ")", "{", "return", "errors", ".", "Wrapf", "(", "ErrInvalidAttachedTrytes", ",", "\"", "\"", ",", "i", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateAttachedTransactionTrytes", "validates", "the", "given", "attached", "transaction", "trytes", "." ]

[ "func", "ValidateTags", "(", "tags", "...", "Trytes", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "for", "i", ":=", "range", "tags", "{", "if", "!", "IsTag", "(", "tags", "[", "i", "]", ")", "{", "return", "errors", ".", "Wrapf", "(", "ErrInvalidTag", ",", "\"", "\"", ",", "tags", "[", "i", "]", ",", "i", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateTags", "validates", "the", "given", "tags", "." ]

[ "func", "ValidateSeed", "(", "seed", "Trytes", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "if", "!", "IsTrytesOfExactLength", "(", "seed", ",", "HashTrytesSize", ")", "{", "return", "ErrInvalidSeed", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateSeed", "validates", "the", "given", "seed", "." ]

[ "func", "ValidateStartEndOptions", "(", "start", "uint64", ",", "end", "*", "uint64", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "if", "end", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "e", ":=", "*", "end", "\n", "if", "start", ">", "e", "||", "e", ">", "start", "+", "MaxIndexDiff", "{", "return", "ErrInvalidStartEndOptions", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateStartEndOptions", "validates", "the", "given", "start", "and", "optional", "end", "option", "." ]

[ "func", "ValidateTransfers", "(", "transfers", "...", "bundle", ".", "Transfer", ")", "Validatable", "{", "return", "func", "(", ")", "error", "{", "for", "i", ":=", "range", "transfers", "{", "transfer", ":=", "&", "transfers", "[", "i", "]", "\n", "if", "IsHash", "(", "transfer", ".", "Address", ")", "&&", "(", "transfer", ".", "Message", "==", "\"", "\"", "||", "IsTrytes", "(", "transfer", ".", "Message", ")", ")", "||", "(", "transfer", ".", "Tag", "==", "\"", "\"", "||", "IsTag", "(", "transfer", ".", "Tag", ")", ")", "{", "continue", "\n", "}", "\n", "return", "ErrInvalidTransfer", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "ValidateTransfers", "validates", "the", "given", "transfers", "." ]

[ "func", "New224", "(", ")", "hash", ".", "Hash", "{", "if", "h", ":=", "new224Asm", "(", ")", ";", "h", "!=", "nil", "{", "return", "h", "\n", "}", "\n", "return", "&", "state", "{", "rate", ":", "144", ",", "outputLen", ":", "28", ",", "dsbyte", ":", "0x01", "}", "\n", "}" ]

[ "New224", "creates", "a", "new", "SHA3", "-", "224", "hash", ".", "Its", "generic", "security", "strength", "is", "224", "bits", "against", "preimage", "attacks", "and", "112", "bits", "against", "collision", "attacks", "." ]

[ "func", "New256", "(", ")", "hash", ".", "Hash", "{", "if", "h", ":=", "new256Asm", "(", ")", ";", "h", "!=", "nil", "{", "return", "h", "\n", "}", "\n", "return", "&", "state", "{", "rate", ":", "136", ",", "outputLen", ":", "32", ",", "dsbyte", ":", "0x01", "}", "\n", "}" ]

[ "New256", "creates", "a", "new", "SHA3", "-", "256", "hash", ".", "Its", "generic", "security", "strength", "is", "256", "bits", "against", "preimage", "attacks", "and", "128", "bits", "against", "collision", "attacks", "." ]

[ "func", "New384", "(", ")", "hash", ".", "Hash", "{", "if", "h", ":=", "new384Asm", "(", ")", ";", "h", "!=", "nil", "{", "return", "h", "\n", "}", "\n", "return", "&", "state", "{", "rate", ":", "104", ",", "outputLen", ":", "48", ",", "dsbyte", ":", "0x01", "}", "\n", "}" ]

[ "New384", "creates", "a", "new", "SHA3", "-", "384", "hash", ".", "Its", "generic", "security", "strength", "is", "384", "bits", "against", "preimage", "attacks", "and", "192", "bits", "against", "collision", "attacks", "." ]

[ "func", "New512", "(", ")", "hash", ".", "Hash", "{", "if", "h", ":=", "new512Asm", "(", ")", ";", "h", "!=", "nil", "{", "return", "h", "\n", "}", "\n", "return", "&", "state", "{", "rate", ":", "72", ",", "outputLen", ":", "64", ",", "dsbyte", ":", "0x01", "}", "\n", "}" ]

[ "New512", "creates", "a", "new", "SHA3", "-", "512", "hash", ".", "Its", "generic", "security", "strength", "is", "512", "bits", "against", "preimage", "attacks", "and", "256", "bits", "against", "collision", "attacks", "." ]

[ "func", "Sum224", "(", "data", "[", "]", "byte", ")", "(", "digest", "[", "28", "]", "byte", ")", "{", "h", ":=", "New224", "(", ")", "\n", "h", ".", "Write", "(", "data", ")", "\n", "h", ".", "Sum", "(", "digest", "[", ":", "0", "]", ")", "\n", "return", "\n", "}" ]

[ "Sum224", "returns", "the", "SHA3", "-", "224", "digest", "of", "the", "data", "." ]

[ "func", "Sum256", "(", "data", "[", "]", "byte", ")", "(", "digest", "[", "32", "]", "byte", ")", "{", "h", ":=", "New256", "(", ")", "\n", "h", ".", "Write", "(", "data", ")", "\n", "h", ".", "Sum", "(", "digest", "[", ":", "0", "]", ")", "\n", "return", "\n", "}" ]

[ "Sum256", "returns", "the", "SHA3", "-", "256", "digest", "of", "the", "data", "." ]

[ "func", "Sum384", "(", "data", "[", "]", "byte", ")", "(", "digest", "[", "48", "]", "byte", ")", "{", "h", ":=", "New384", "(", ")", "\n", "h", ".", "Write", "(", "data", ")", "\n", "h", ".", "Sum", "(", "digest", "[", ":", "0", "]", ")", "\n", "return", "\n", "}" ]

[ "Sum384", "returns", "the", "SHA3", "-", "384", "digest", "of", "the", "data", "." ]

[ "func", "Sum512", "(", "data", "[", "]", "byte", ")", "(", "digest", "[", "64", "]", "byte", ")", "{", "h", ":=", "New512", "(", ")", "\n", "h", ".", "Write", "(", "data", ")", "\n", "h", ".", "Sum", "(", "digest", "[", ":", "0", "]", ")", "\n", "return", "\n", "}" ]

[ "Sum512", "returns", "the", "SHA3", "-", "512", "digest", "of", "the", "data", "." ]

[ "func", "Subseed", "(", "seed", "Trytes", ",", "index", "uint64", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "Trits", ",", "error", ")", "{", "if", "err", ":=", "ValidTrytes", "(", "seed", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "len", "(", "seed", ")", "!=", "HashTrinarySize", "/", "TrinaryRadix", "{", "return", "nil", ",", "ErrInvalidSeed", "\n", "}", "\n\n", "trits", ",", "err", ":=", "TrytesToTrits", "(", "seed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "incrementedSeed", ":=", "AddTrits", "(", "trits", ",", "IntToTrits", "(", "int64", "(", "index", ")", ")", ")", "\n\n", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n", "defer", "h", ".", "Reset", "(", ")", "\n\n", "err", "=", "h", ".", "Absorb", "(", "incrementedSeed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "subseed", ",", "err", ":=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "subseed", ",", "err", "\n", "}" ]

[ "Subseed", "takes", "a", "seed", "and", "an", "index", "and", "returns", "the", "given", "subseed", ".", "Optionally", "takes", "the", "SpongeFunction", "to", "use", ".", "Default", "is", "Kerl", "." ]

[ "func", "Address", "(", "digests", "Trits", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "Trits", ",", "error", ")", "{", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n", "defer", "h", ".", "Reset", "(", ")", "\n\n", "if", "err", ":=", "h", ".", "Absorb", "(", "digests", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "}" ]

[ "Address", "generates", "the", "address", "trits", "from", "the", "given", "digests", ".", "Optionally", "takes", "the", "SpongeFunction", "to", "use", ".", "Default", "is", "Kerl", "." ]

[ "func", "Digest", "(", "bundleHash", "[", "]", "int8", ",", "signatureFragment", "Trits", ",", "startOffset", "int", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "Trits", ",", "error", ")", "{", "sigLength", ":=", "len", "(", "signatureFragment", ")", "\n\n", "secLvl", ",", "err", ":=", "GetSecurityLevel", "(", "bundleHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "sigFrag", ":=", "make", "(", "Trits", ",", "sigLength", ")", "\n", "copy", "(", "sigFrag", ",", "signatureFragment", "[", ":", "sigLength", "]", ")", "\n\n", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n", "defer", "h", ".", "Reset", "(", ")", "\n\n", "dig", ":=", "make", "(", "Trits", ",", "HashTrinarySize", ")", "\n", "sig", ":=", "make", "(", "Trits", ",", "HashTrinarySize", ")", "\n\n", "i", ":=", "startOffset", "%", "int", "(", "secLvl", ")", "\n", "for", "digLength", ":=", "0", ";", "digLength", "<", "sigLength", ";", "{", "for", "j", ":=", "i", "*", "ISSChunkLength", ";", "j", "<", "(", "i", "+", "1", ")", "*", "ISSChunkLength", "&&", "digLength", "<", "sigLength", ";", "j", "+=", "TrinaryRadix", "{", "copy", "(", "sig", ",", "sigFrag", "[", "digLength", ":", "digLength", "+", "HashTrinarySize", "]", ")", "\n\n", "to", ":=", "(", "bundleHash", "[", "j", "]", "+", "bundleHash", "[", "j", "+", "1", "]", "*", "3", "+", "bundleHash", "[", "j", "+", "2", "]", "*", "9", ")", "-", "MinTryteValue", "\n\n", "for", "k", ":=", "0", ";", "k", "<", "int", "(", "to", ")", ";", "k", "++", "{", "err", ":=", "h", ".", "Absorb", "(", "sig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "sig", ",", "err", "=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "h", ".", "Reset", "(", ")", "\n", "}", "\n\n", "copy", "(", "sigFrag", "[", "digLength", ":", "]", ",", "sig", ")", "\n", "digLength", "+=", "HashTrinarySize", "\n", "}", "\n\n", "i", "=", "(", "i", "+", "1", ")", "%", "int", "(", "secLvl", ")", "\n", "}", "\n\n", "err", "=", "h", ".", "Absorb", "(", "sigFrag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "dig", ",", "err", "=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "dig", ",", "nil", "\n", "}" ]

[ "Digest", "computes", "the", "digest", "derived", "from", "the", "signature", "fragment", "and", "bundle", "hash", ".", "Optionally", "takes", "the", "SpongeFunction", "to", "use", ".", "Default", "is", "Kerl", "." ]

[ "func", "AVXProofOfWork", "(", "trytes", "Trytes", ",", "mwm", "int", ",", "parallelism", "...", "int", ")", "(", "Trytes", ",", "error", ")", "{", "return", "avxProofOfWork", "(", "trytes", ",", "mwm", ",", "nil", ",", "parallelism", "...", ")", "\n", "}" ]

[ "AVXProofOfWork", "does", "Proof", "-", "of", "-", "Work", "on", "the", "given", "trytes", "using", "AVX", "instructions", "." ]

[ "func", "KerlTritsToBytes", "(", "trits", "Trits", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "!", "CanBeHash", "(", "trits", ")", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "ErrInvalidTritsLength", ",", "\"", "\"", ",", "HashTrinarySize", ")", "\n", "}", "\n\n", "allNeg", ":=", "true", "\n", "// last position should be always zero.", "for", "_", ",", "e", ":=", "range", "trits", "[", "0", ":", "HashTrinarySize", "-", "1", "]", "{", "if", "e", "!=", "-", "1", "{", "allNeg", "=", "false", "\n", "break", "\n", "}", "\n", "}", "\n\n", "// trit to BigInt", "b", ":=", "make", "(", "[", "]", "byte", ",", "48", ")", "// 48 bytes/384 bits", "\n\n", "// 12 * 32 bits = 384 bits", "base", ":=", "(", "*", "(", "*", "[", "]", "uint32", ")", "(", "unsafe", ".", "Pointer", "(", "&", "b", ")", ")", ")", "[", "0", ":", "IntLength", "]", "\n\n", "if", "allNeg", "{", "// if all trits are -1 then we're half way through all the numbers,", "// since they're in two's complement notation.", "copy", "(", "base", ",", "halfThree", ")", "\n\n", "// compensate for setting the last position to zero.", "bigint", ".", "Not", "(", "base", ")", "\n", "bigint", ".", "AddSmall", "(", "base", ",", "1", ")", "\n\n", "return", "bigint", ".", "Reverse", "(", "b", ")", ",", "nil", "\n", "}", "\n\n", "revT", ":=", "make", "(", "[", "]", "int8", ",", "len", "(", "trits", ")", ")", "\n", "copy", "(", "revT", ",", "trits", ")", "\n", "size", ":=", "1", "\n\n", "for", "_", ",", "e", ":=", "range", "ReverseTrits", "(", "revT", "[", "0", ":", "HashTrinarySize", "-", "1", "]", ")", "{", "sz", ":=", "size", "\n", "var", "carry", "uint32", "\n", "for", "j", ":=", "0", ";", "j", "<", "sz", ";", "j", "++", "{", "v", ":=", "uint64", "(", "base", "[", "j", "]", ")", "*", "uint64", "(", "TrinaryRadix", ")", "+", "uint64", "(", "carry", ")", "\n", "carry", "=", "uint32", "(", "v", ">>", "32", ")", "\n", "base", "[", "j", "]", "=", "uint32", "(", "v", ")", "\n", "}", "\n\n", "if", "carry", ">", "0", "{", "base", "[", "sz", "]", "=", "carry", "\n", "size", "=", "size", "+", "1", "\n", "}", "\n\n", "trit", ":=", "uint32", "(", "e", "+", "1", ")", "\n\n", "ns", ":=", "bigint", ".", "AddSmall", "(", "base", ",", "trit", ")", "\n", "if", "ns", ">", "size", "{", "size", "=", "ns", "\n", "}", "\n", "}", "\n\n", "if", "!", "bigint", ".", "IsNull", "(", "base", ")", "{", "if", "bigint", ".", "MustCmp", "(", "halfThree", ",", "base", ")", "<=", "0", "{", "// base >= HALF_3", "// just do base - HALF_3", "bigint", ".", "MustSub", "(", "base", ",", "halfThree", ")", "\n", "}", "else", "{", "// we don'trits have a wrapping sub.", "// so let's use some bit magic to achieve it", "tmp", ":=", "make", "(", "[", "]", "uint32", ",", "IntLength", ")", "\n", "copy", "(", "tmp", ",", "halfThree", ")", "\n", "bigint", ".", "MustSub", "(", "tmp", ",", "base", ")", "\n", "bigint", ".", "Not", "(", "tmp", ")", "\n", "bigint", ".", "AddSmall", "(", "tmp", ",", "1", ")", "\n", "copy", "(", "base", ",", "tmp", ")", "\n", "}", "\n", "}", "\n", "return", "bigint", ".", "Reverse", "(", "b", ")", ",", "nil", "\n", "}" ]

[ "KerlTritsToBytes", "is", "only", "defined", "for", "hashes", "i", ".", "e", ".", "slices", "of", "trits", "of", "length", "243", ".", "It", "returns", "48", "bytes", "." ]

[ "func", "KerlBytesToTrits", "(", "b", "[", "]", "byte", ")", "(", "Trits", ",", "error", ")", "{", "if", "len", "(", "b", ")", "!=", "HashBytesSize", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "ErrInvalidBytesLength", ",", "\"", "\"", ",", "HashBytesSize", ")", "\n", "}", "\n\n", "rb", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "b", ")", ")", "\n", "copy", "(", "rb", ",", "b", ")", "\n", "bigint", ".", "Reverse", "(", "rb", ")", "\n\n", "t", ":=", "Trits", "(", "make", "(", "[", "]", "int8", ",", "HashTrinarySize", ")", ")", "\n", "t", "[", "HashTrinarySize", "-", "1", "]", "=", "0", "\n\n", "base", ":=", "(", "*", "(", "*", "[", "]", "uint32", ")", "(", "unsafe", ".", "Pointer", "(", "&", "rb", ")", ")", ")", "[", "0", ":", "IntLength", "]", "// 12 * 32 bits = 384 bits", "\n\n", "if", "bigint", ".", "IsNull", "(", "base", ")", "{", "return", "t", ",", "nil", "\n", "}", "\n\n", "var", "flipTrits", "bool", "\n\n", "// Check if the MSB is 0, i.e. we have a positive number", "msbM", ":=", "(", "unsafe", ".", "Sizeof", "(", "base", "[", "IntLength", "-", "1", "]", ")", "*", "8", ")", "-", "1", "\n\n", "switch", "{", "case", "base", "[", "IntLength", "-", "1", "]", ">>", "msbM", "==", "0", ":", "bigint", ".", "MustAdd", "(", "base", ",", "halfThree", ")", "\n", "default", ":", "bigint", ".", "Not", "(", "base", ")", "\n", "if", "bigint", ".", "MustCmp", "(", "base", ",", "halfThree", ")", "==", "1", "{", "bigint", ".", "MustSub", "(", "base", ",", "halfThree", ")", "\n", "flipTrits", "=", "true", "\n", "}", "else", "{", "bigint", ".", "AddSmall", "(", "base", ",", "1", ")", "\n", "tmp", ":=", "make", "(", "[", "]", "uint32", ",", "IntLength", ")", "\n", "copy", "(", "tmp", ",", "halfThree", ")", "\n", "bigint", ".", "MustSub", "(", "tmp", ",", "base", ")", "\n", "copy", "(", "base", ",", "tmp", ")", "\n", "}", "\n", "}", "\n\n", "var", "rem", "uint64", "\n", "for", "i", ":=", "range", "t", "[", "0", ":", "HashTrinarySize", "-", "1", "]", "{", "rem", "=", "0", "\n", "for", "j", ":=", "IntLength", "-", "1", ";", "j", ">=", "0", ";", "j", "--", "{", "lhs", ":=", "(", "rem", "<<", "32", ")", "|", "uint64", "(", "base", "[", "j", "]", ")", "\n", "rhs", ":=", "uint64", "(", "TrinaryRadix", ")", "\n", "q", ":=", "uint32", "(", "lhs", "/", "rhs", ")", "\n", "r", ":=", "uint32", "(", "lhs", "%", "rhs", ")", "\n", "base", "[", "j", "]", "=", "q", "\n", "rem", "=", "uint64", "(", "r", ")", "\n", "}", "\n", "t", "[", "i", "]", "=", "int8", "(", "rem", ")", "-", "1", "\n", "}", "\n\n", "if", "flipTrits", "{", "for", "i", ":=", "range", "t", "{", "t", "[", "i", "]", "=", "-", "t", "[", "i", "]", "\n", "}", "\n", "}", "\n\n", "return", "t", ",", "nil", "\n", "}" ]

[ "KerlBytesToTrits", "converts", "binary", "to", "trinary" ]

[ "func", "(", "b", "*", "Builder", ")", "Build", "(", "plugins", "...", "account", ".", "Plugin", ")", "(", "account", ".", "Account", ",", "error", ")", "{", "if", "b", ".", "settings", ".", "AddrGen", "==", "nil", "{", "b", ".", "settings", ".", "AddrGen", "=", "account", ".", "DefaultAddrGen", "(", "b", ".", "settings", ".", "SeedProv", ",", "true", ")", "\n", "}", "\n", "if", "b", ".", "settings", ".", "PrepareTransfers", "==", "nil", "{", "b", ".", "settings", ".", "PrepareTransfers", "=", "account", ".", "DefaultPrepareTransfers", "(", "b", ".", "settings", ".", "API", ",", "b", ".", "settings", ".", "SeedProv", ")", "\n", "}", "\n", "for", "_", ",", "p", ":=", "range", "plugins", "{", "b", ".", "settings", ".", "Plugins", "[", "p", ".", "Name", "(", ")", "]", "=", "p", "\n", "}", "\n", "settsCopy", ":=", "*", "b", ".", "settings", "\n", "return", "account", ".", "NewAccount", "(", "&", "settsCopy", ")", "\n", "}" ]

[ "Build", "adds", "the", "given", "plugins", "and", "creates", "the", "account", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithAPI", "(", "api", "*", "api", ".", "API", ")", "*", "Builder", "{", "b", ".", "settings", ".", "API", "=", "api", "\n", "return", "b", "\n", "}" ]

[ "API", "sets", "the", "underlying", "API", "to", "use", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithStore", "(", "store", "store", ".", "Store", ")", "*", "Builder", "{", "b", ".", "settings", ".", "Store", "=", "store", "\n", "return", "b", "\n", "}" ]

[ "Store", "sets", "the", "underlying", "store", "to", "use", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithSeedProvider", "(", "seedProv", "account", ".", "SeedProvider", ")", "*", "Builder", "{", "b", ".", "settings", ".", "SeedProv", "=", "seedProv", "\n", "return", "b", "\n", "}" ]

[ "SeedProvider", "sets", "the", "underlying", "SeedProvider", "to", "use", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithAddrGenFunc", "(", "f", "account", ".", "AddrGenFunc", ")", "*", "Builder", "{", "b", ".", "settings", ".", "AddrGen", "=", "f", "\n", "return", "b", "\n", "}" ]

[ "WithAddrGenFunc", "sets", "the", "address", "generation", "function", "to", "use", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithPrepareTransfersFunc", "(", "f", "account", ".", "PrepareTransfersFunc", ")", "*", "Builder", "{", "b", ".", "settings", ".", "PrepareTransfers", "=", "f", "\n", "return", "b", "\n", "}" ]

[ "WithPrepareTransfersFunc", "sets", "the", "prepare", "transfers", "function", "to", "use", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithSeed", "(", "seed", "Trytes", ")", "*", "Builder", "{", "b", ".", "settings", ".", "SeedProv", "=", "account", ".", "NewInMemorySeedProvider", "(", "seed", ")", "\n", "return", "b", "\n", "}" ]

[ "Seed", "sets", "the", "underlying", "seed", "to", "use", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithMWM", "(", "mwm", "uint64", ")", "*", "Builder", "{", "b", ".", "settings", ".", "MWM", "=", "mwm", "\n", "return", "b", "\n", "}" ]

[ "MWM", "sets", "the", "minimum", "weight", "magnitude", "used", "to", "send", "transactions", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithDepth", "(", "depth", "uint64", ")", "*", "Builder", "{", "b", ".", "settings", ".", "Depth", "=", "depth", "\n", "return", "b", "\n", "}" ]

[ "Depth", "sets", "the", "depth", "used", "when", "searching", "for", "transactions", "to", "approve", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithSecurityLevel", "(", "level", "consts", ".", "SecurityLevel", ")", "*", "Builder", "{", "b", ".", "settings", ".", "SecurityLevel", "=", "level", "\n", "return", "b", "\n", "}" ]

[ "The", "overall", "security", "level", "used", "by", "the", "account", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithTimeSource", "(", "timesource", "timesrc", ".", "TimeSource", ")", "*", "Builder", "{", "b", ".", "settings", ".", "TimeSource", "=", "timesource", "\n", "return", "b", "\n", "}" ]

[ "TimeSource", "sets", "the", "TimeSource", "to", "use", "to", "get", "the", "current", "time", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithInputSelectionStrategy", "(", "strat", "account", ".", "InputSelectionFunc", ")", "*", "Builder", "{", "b", ".", "settings", ".", "InputSelectionStrat", "=", "strat", "\n", "return", "b", "\n", "}" ]

[ "InputSelectionFunc", "sets", "the", "strategy", "to", "determine", "inputs", "and", "usable", "balance", "." ]

[ "func", "(", "b", "*", "Builder", ")", "WithEvents", "(", "em", "event", ".", "EventMachine", ")", "*", "Builder", "{", "b", ".", "settings", ".", "EventMachine", "=", "em", "\n", "return", "b", "\n", "}" ]

[ "WithEvents", "instructs", "the", "account", "to", "emit", "events", "using", "the", "given", "EventMachine", "." ]

[ "func", "NewQuorumHTTPClient", "(", "settings", "interface", "{", "}", ")", "(", "Provider", ",", "error", ")", "{", "client", ":=", "&", "quorumhttpclient", "{", "}", "\n", "if", "err", ":=", "client", ".", "SetSettings", "(", "settings", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "client", ",", "nil", "\n", "}" ]

[ "NewQuorumHTTPClient", "creates", "a", "new", "quorum", "based", "Http", "Provider", "." ]

[ "func", "extractSubTangleMilestoneHash", "(", "data", "[", "]", "byte", ")", "(", "string", ",", "error", ")", "{", "firstColonIndex", ":=", "bytes", ".", "Index", "(", "data", ",", "colonSep", "[", ":", "]", ")", "\n", "if", "firstColonIndex", "==", "-", "1", "{", "return", "\"", "\"", ",", "errors", ".", "Wrap", "(", "ErrNoLatestSolidSubtangleInfo", ",", "\"", "\"", ")", "\n", "}", "\n", "leadingQuoteIndex", ":=", "bytes", ".", "Index", "(", "data", "[", "firstColonIndex", "+", "1", ":", "]", ",", "quoteSep", "[", ":", "]", ")", "\n", "if", "leadingQuoteIndex", "==", "-", "1", "{", "return", "\"", "\"", ",", "errors", ".", "Wrap", "(", "ErrNoLatestSolidSubtangleInfo", ",", "\"", "\"", ")", "\n", "}", "\n", "leadingQuoteIndex", "=", "firstColonIndex", "+", "1", "+", "leadingQuoteIndex", "\n", "endingQuoteIndex", ":=", "bytes", ".", "Index", "(", "data", "[", "leadingQuoteIndex", "+", "1", ":", "]", ",", "quoteSep", "[", ":", "]", ")", "\n", "if", "endingQuoteIndex", "==", "-", "1", "{", "return", "\"", "\"", ",", "errors", ".", "Wrap", "(", "ErrNoLatestSolidSubtangleInfo", ",", "\"", "\"", ")", "\n", "}", "\n", "endingQuoteIndex", "=", "leadingQuoteIndex", "+", "1", "+", "endingQuoteIndex", "\n", "return", "string", "(", "data", "[", "leadingQuoteIndex", "+", "1", ":", "endingQuoteIndex", "]", ")", ",", "nil", "\n", "}" ]

[ "extracts", "the", "latest", "solid", "subtangle", "milestone", "hash", "of", "a", "reduced", "getNodeInfo", "response" ]

[ "func", "extractSubTangleMilestoneIndex", "(", "data", "[", "]", "byte", ")", "(", "uint64", ",", "error", ")", "{", "lastColonIndex", ":=", "bytes", ".", "LastIndex", "(", "data", ",", "colonSep", "[", ":", "]", ")", "\n", "if", "lastColonIndex", "==", "-", "1", "{", "return", "0", ",", "errors", ".", "Wrap", "(", "ErrNoLatestSolidSubtangleInfo", ",", "\"", "\"", ")", "\n", "}", "\n", "index", ":=", "data", "[", "lastColonIndex", "+", "1", ":", "len", "(", "data", ")", "-", "1", "]", "\n", "return", "strconv", ".", "ParseUint", "(", "string", "(", "index", ")", ",", "10", ",", "64", ")", "\n", "}" ]

[ "extracts", "the", "latest", "solid", "subtangle", "milestone", "index", "of", "a", "reduced", "getNodeInfo", "response" ]

[ "func", "(", "hc", "*", "quorumhttpclient", ")", "injectDefault", "(", "cmd", "interface", "{", "}", ",", "out", "interface", "{", "}", ")", "bool", "{", "// use defaults for non quorum results", "if", "hc", ".", "settings", ".", "Defaults", "==", "nil", "{", "return", "false", "\n", "}", "\n", "switch", "x", ":=", "cmd", ".", "(", "type", ")", "{", "case", "*", "WereAddressesSpentFromCommand", ":", "if", "hc", ".", "settings", ".", "Defaults", ".", "WereAddressesSpentFrom", "!=", "nil", "{", "states", ":=", "make", "(", "[", "]", "bool", ",", "len", "(", "x", ".", "Addresses", ")", ")", "\n", "for", "i", ":=", "range", "states", "{", "states", "[", "i", "]", "=", "*", "hc", ".", "settings", ".", "Defaults", ".", "WereAddressesSpentFrom", "\n", "}", "\n", "out", ".", "(", "*", "WereAddressesSpentFromResponse", ")", ".", "States", "=", "states", "\n", "return", "true", "\n", "}", "\n", "case", "*", "GetInclusionStatesCommand", ":", "if", "hc", ".", "settings", ".", "Defaults", ".", "GetInclusionStates", "!=", "nil", "{", "states", ":=", "make", "(", "[", "]", "bool", ",", "len", "(", "x", ".", "Transactions", ")", ")", "\n", "for", "i", ":=", "range", "states", "{", "states", "[", "i", "]", "=", "*", "hc", ".", "settings", ".", "Defaults", ".", "GetInclusionStates", "\n", "}", "\n", "out", ".", "(", "*", "GetInclusionStatesResponse", ")", ".", "States", "=", "states", "\n", "return", "true", "\n", "}", "\n", "case", "*", "GetBalancesCommand", ":", "if", "hc", ".", "settings", ".", "Defaults", ".", "GetBalances", "!=", "nil", "{", "balances", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "x", ".", "Addresses", ")", ")", "\n", "for", "i", ":=", "range", "balances", "{", "balances", "[", "i", "]", "=", "strconv", ".", "Itoa", "(", "int", "(", "*", "hc", ".", "settings", ".", "Defaults", ".", "GetBalances", ")", ")", "\n", "}", "\n", "out", ".", "(", "*", "GetBalancesResponse", ")", ".", "Balances", "=", "balances", "\n", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "injects", "the", "optional", "default", "set", "data", "into", "the", "response" ]

[ "func", "sliceOutDurationField", "(", "data", "[", "]", "byte", ")", "[", "]", "byte", "{", "indexOfDurationField", ":=", "bytes", ".", "LastIndex", "(", "data", ",", "durationKey", "[", ":", "]", ")", "\n", "if", "indexOfDurationField", "==", "-", "1", "{", "return", "data", "\n", "}", "\n", "curlyBraceIndex", ":=", "bytes", ".", "Index", "(", "data", "[", "indexOfDurationField", ":", "]", ",", "[", "]", "byte", "{", "closingCurlyBraceAscii", "}", ")", "\n", "return", "append", "(", "data", "[", ":", "indexOfDurationField", "-", "1", "]", ",", "data", "[", "indexOfDurationField", "+", "curlyBraceIndex", ":", "]", "...", ")", "\n", "}" ]

[ "slices", "out", "a", "byte", "slice", "without", "the", "duration", "field", ".", "querying", "multiple", "nodes", "will", "always", "lead", "to", "different", "durations", "and", "hence", "must", "be", "removed", "when", "hasing", "the", "entire", "response", "." ]

[ "func", "sliceOutInfoField", "(", "data", "[", "]", "byte", ")", "[", "]", "byte", "{", "infoIndex", ":=", "bytes", ".", "LastIndex", "(", "data", ",", "infoKey", "[", ":", "]", ")", "\n", "if", "infoIndex", "==", "-", "1", "{", "return", "data", "\n", "}", "\n", "// if the info field is empty, don't create a copy", "if", "i", ":=", "bytes", ".", "LastIndex", "(", "data", ",", "emptyInfoKey", "[", ":", "]", ")", ";", "i", "!=", "-", "1", "{", "return", "data", "\n", "}", "\n", "// create a copy as we want to keep the schematics", "// of the original slice", "c", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "data", ")", ")", "\n", "copy", "(", "c", ",", "data", ")", "\n", "return", "append", "(", "c", "[", ":", "infoIndex", "-", "1", "]", ",", "closingCurlyBraceAscii", ")", "\n", "}" ]

[ "slices", "out", "a", "byte", "slice", "without", "the", "info", "field", "of", "check", "consistency", "calls", ".", "querying", "multiple", "nodes", "will", "lead", "to", "different", "info", "messages", "when", "the", "state", "is", "false", "of", "the", "responses", "." ]

[ "func", "sliceOutMilestoneIndexField", "(", "data", "[", "]", "byte", ")", "[", "]", "byte", "{", "indexOfMilestoneIndex", ":=", "bytes", ".", "LastIndex", "(", "data", ",", "milestoneIndexKey", "[", ":", "]", ")", "\n", "if", "indexOfMilestoneIndex", "==", "-", "1", "{", "return", "data", "\n", "}", "\n", "c", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "data", ")", ")", "\n", "copy", "(", "c", ",", "data", ")", "\n", "return", "append", "(", "c", "[", ":", "indexOfMilestoneIndex", "-", "2", "]", ",", "closingCurlyBraceAscii", ")", "\n", "}" ]

[ "slices", "out", "a", "byte", "slice", "without", "the", "milestone", "index", "field", "for", "get", "balances", "calls", ".", "even", "when", "querying", "multiple", "nodes", "with", "the", "same", "reference", "the", "IRI", "node", "s", "latest", "snapshot", "index", "is", "returned", "in", "the", "response", "which", "must", "thereby", "be", "filtered", "out", "." ]

[ "func", "MustAdd", "(", "b", "[", "]", "uint32", ",", "rh", "[", "]", "uint32", ")", "{", "if", "len", "(", "b", ")", "!=", "len", "(", "rh", ")", "{", "panic", "(", "ErrUnequallySizedSlices", ")", "\n", "}", "\n\n", "carry", ":=", "false", "\n\n", "for", "i", ":=", "range", "b", "{", "v", ",", "c", ":=", "FullAdd", "(", "b", "[", "i", "]", ",", "rh", "[", "i", "]", ",", "carry", ")", "\n", "b", "[", "i", "]", "=", "uint32", "(", "v", ")", "\n", "carry", "=", "c", "\n", "}", "\n", "}" ]

[ "MustAdd", "adds", "the", "given", "big", "ints", "together", "." ]

[ "func", "MustSub", "(", "b", "[", "]", "uint32", ",", "rh", "[", "]", "uint32", ")", "{", "if", "len", "(", "b", ")", "!=", "len", "(", "rh", ")", "{", "panic", "(", "ErrUnequallySizedSlices", ")", "\n", "}", "\n\n", "noborrow", ":=", "true", "\n\n", "for", "i", ":=", "range", "b", "{", "v", ",", "c", ":=", "FullAdd", "(", "b", "[", "i", "]", ",", "^", "rh", "[", "i", "]", ",", "noborrow", ")", "\n", "b", "[", "i", "]", "=", "uint32", "(", "v", ")", "\n", "noborrow", "=", "c", "\n", "}", "\n\n", "if", "!", "noborrow", "{", "panic", "(", "ErrSubtractionWithLeftovers", ")", "\n", "}", "\n", "}" ]

[ "MustSub", "subtracts", "rh", "from", "b", "." ]

[ "func", "IsNull", "(", "b", "[", "]", "uint32", ")", "bool", "{", "for", "i", ":=", "range", "b", "{", "if", "b", "[", "i", "]", "!=", "0", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsNull", "checks", "whether", "the", "given", "big", "int", "value", "is", "null", "." ]

[ "func", "MustCmp", "(", "lh", ",", "rh", "[", "]", "uint32", ")", "int", "{", "if", "len", "(", "lh", ")", "!=", "len", "(", "rh", ")", "{", "panic", "(", "ErrUnequallySizedSlices", ")", "\n", "}", "\n\n", "// put LSB first", "rlh", ":=", "make", "(", "[", "]", "uint32", ",", "len", "(", "lh", ")", ")", "\n", "copy", "(", "rlh", ",", "lh", ")", "\n", "ReverseU", "(", "rlh", ")", "\n\n", "rrh", ":=", "make", "(", "[", "]", "uint32", ",", "len", "(", "rh", ")", ")", "\n", "copy", "(", "rrh", ",", "rh", ")", "\n", "ReverseU", "(", "rrh", ")", "\n\n", "for", "i", ":=", "range", "rlh", "{", "switch", "{", "case", "rlh", "[", "i", "]", "<", "rrh", "[", "i", "]", ":", "return", "-", "1", "\n", "case", "rlh", "[", "i", "]", ">", "rrh", "[", "i", "]", ":", "return", "1", "\n", "}", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "MustCmp", "compares", "the", "given", "big", "ints", "with", "each", "other", "." ]

[ "func", "AddSmall", "(", "b", "[", "]", "uint32", ",", "a", "uint32", ")", "int", "{", "v", ",", "carry", ":=", "FullAdd", "(", "b", "[", "0", "]", ",", "a", ",", "false", ")", "\n", "b", "[", "0", "]", "=", "uint32", "(", "v", ")", "// uint is at least 32 bit", "\n\n", "var", "i", "int", "\n", "for", "i", "=", "1", ";", "carry", ";", "i", "++", "{", "vi", ",", "c", ":=", "FullAdd", "(", "b", "[", "i", "]", ",", "0", ",", "carry", ")", "\n", "b", "[", "i", "]", "=", "uint32", "(", "vi", ")", "\n", "carry", "=", "c", "\n", "}", "\n\n", "return", "i", "\n", "}" ]

[ "AddSmall", "adds", "a", "small", "number", "to", "a", "big", "int", "and", "returns", "the", "index", "of", "the", "last", "carry", "over", "." ]

[ "func", "FullAdd", "(", "lh", ",", "rh", "uint32", ",", "carry", "bool", ")", "(", "uint", ",", "bool", ")", "{", "v", ",", "c1", ":=", "AddWithOverflow", "(", "lh", ",", "rh", ")", "\n", "var", "c2", "bool", "\n", "if", "carry", "{", "v", ",", "c2", "=", "AddWithOverflow", "(", "uint32", "(", "v", ")", ",", "1", ")", "\n", "}", "\n\n", "return", "v", ",", "c1", "||", "c2", "\n", "}" ]

[ "FullAdd", "adds", "left", "and", "right", "together", "and", "whether", "it", "overflowed", "." ]

[ "func", "AddWithOverflow", "(", "lh", ",", "rh", "uint32", ")", "(", "uint", ",", "bool", ")", "{", "return", "uint", "(", "lh", "+", "rh", ")", ",", "lh", ">", "math", ".", "MaxUint32", "-", "rh", "\n", "}" ]

[ "AddWithOverflow", "returns", "left", "hand", "+", "right", "hand", "and", "whether", "it", "overflowed", "." ]

[ "func", "Reverse", "(", "a", "[", "]", "byte", ")", "[", "]", "byte", "{", "for", "left", ",", "right", ":=", "0", ",", "len", "(", "a", ")", "-", "1", ";", "left", "<", "right", ";", "left", ",", "right", "=", "left", "+", "1", ",", "right", "-", "1", "{", "a", "[", "left", "]", ",", "a", "[", "right", "]", "=", "a", "[", "right", "]", ",", "a", "[", "left", "]", "\n", "}", "\n\n", "return", "a", "\n", "}" ]

[ "Reverse", "reverses", "the", "given", "byte", "slice", "." ]

[ "func", "ReverseU", "(", "a", "[", "]", "uint32", ")", "[", "]", "uint32", "{", "for", "left", ",", "right", ":=", "0", ",", "len", "(", "a", ")", "-", "1", ";", "left", "<", "right", ";", "left", ",", "right", "=", "left", "+", "1", ",", "right", "-", "1", "{", "a", "[", "left", "]", ",", "a", "[", "right", "]", "=", "a", "[", "right", "]", ",", "a", "[", "left", "]", "\n", "}", "\n\n", "return", "a", "\n", "}" ]

[ "ReverseU", "reverses", "the", "given", "uint32", "slice", "." ]

[ "func", "NewChannelEventListener", "(", "em", "event", ".", "EventMachine", ")", "*", "ChannelEventListener", "{", "return", "&", "ChannelEventListener", "{", "em", ":", "em", ",", "ids", ":", "[", "]", "uint64", "{", "}", "}", "\n", "}" ]

[ "NewChannelEventListener", "creates", "a", "new", "ChannelEventListener", "using", "the", "given", "EventMachine", "." ]

[ "func", "(", "el", "*", "ChannelEventListener", ")", "Close", "(", ")", "error", "{", "el", ".", "idsMu", ".", "Lock", "(", ")", "\n", "defer", "el", ".", "idsMu", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "id", ":=", "range", "el", ".", "ids", "{", "if", "err", ":=", "el", ".", "em", ".", "UnregisterListener", "(", "id", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "frees", "up", "all", "underlying", "channels", "from", "the", "EventMachine", "." ]

[ "func", "(", "el", "*", "ChannelEventListener", ")", "RegPromotions", "(", ")", "*", "ChannelEventListener", "{", "el", ".", "Promoted", "=", "make", "(", "chan", "*", "promoter", ".", "PromotionReattachmentEvent", ")", "\n", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "el", ".", "Promoted", "<-", "data", ".", "(", "*", "promoter", ".", "PromotionReattachmentEvent", ")", "\n", "}", ",", "promoter", ".", "EventPromotion", ")", ")", "\n", "return", "el", "\n", "}" ]

[ "RegPromotions", "registers", "this", "listener", "to", "listen", "for", "promotions", "." ]

[ "func", "(", "el", "*", "ChannelEventListener", ")", "RegReattachments", "(", ")", "*", "ChannelEventListener", "{", "el", ".", "Reattached", "=", "make", "(", "chan", "*", "promoter", ".", "PromotionReattachmentEvent", ")", "\n", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "el", ".", "Reattached", "<-", "data", ".", "(", "*", "promoter", ".", "PromotionReattachmentEvent", ")", "\n", "}", ",", "promoter", ".", "EventReattachment", ")", ")", "\n", "return", "el", "\n", "}" ]

[ "RegReattachments", "registers", "this", "listener", "to", "listen", "for", "reattachments", "." ]

[ "func", "(", "el", "*", "ChannelEventListener", ")", "RegSentTransfers", "(", ")", "*", "ChannelEventListener", "{", "el", ".", "SentTransfer", "=", "make", "(", "chan", "bundle", ".", "Bundle", ")", "\n", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "el", ".", "SentTransfer", "<-", "data", ".", "(", "bundle", ".", "Bundle", ")", "\n", "}", ",", "event", ".", "EventSentTransfer", ")", ")", "\n", "return", "el", "\n", "}" ]

[ "RegSentTransfers", "registers", "this", "listener", "to", "listen", "for", "sent", "off", "transfers", "." ]

[ "func", "(", "el", "*", "ChannelEventListener", ")", "RegConfirmedTransfers", "(", ")", "*", "ChannelEventListener", "{", "el", ".", "TransferConfirmed", "=", "make", "(", "chan", "bundle", ".", "Bundle", ")", "\n", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "el", ".", "TransferConfirmed", "<-", "data", ".", "(", "bundle", ".", "Bundle", ")", "\n", "}", ",", "poller", ".", "EventTransferConfirmed", ")", ")", "\n", "return", "el", "\n", "}" ]

[ "RegConfirmedTransfers", "registers", "this", "listener", "to", "listen", "for", "sent", "off", "confirmed", "transfers", "." ]

[ "func", "(", "el", "*", "ChannelEventListener", ")", "RegReceivingDeposits", "(", ")", "*", "ChannelEventListener", "{", "el", ".", "ReceivingDeposit", "=", "make", "(", "chan", "bundle", ".", "Bundle", ")", "\n", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "el", ".", "ReceivingDeposit", "<-", "data", ".", "(", "bundle", ".", "Bundle", ")", "\n", "}", ",", "poller", ".", "EventReceivingDeposit", ")", ")", "\n", "return", "el", "\n", "}" ]

[ "RegReceivingDeposits", "registers", "this", "listener", "to", "listen", "for", "incoming", "deposits", "which", "are", "not", "yet", "confirmed", "." ]

[ "func", "(", "el", "*", "ChannelEventListener", ")", "All", "(", ")", "*", "ChannelEventListener", "{", "return", "el", ".", "RegAccountShutdown", "(", ")", ".", "RegPromotions", "(", ")", ".", "RegReattachments", "(", ")", ".", "RegSentTransfers", "(", ")", ".", "RegConfirmedTransfers", "(", ")", ".", "RegReceivedDeposits", "(", ")", ".", "RegReceivingDeposits", "(", ")", ".", "RegReceivedMessages", "(", ")", ".", "RegInputSelection", "(", ")", ".", "RegPreparingTransfer", "(", ")", ".", "RegGettingTransactionsToApprove", "(", ")", ".", "RegAttachingToTangle", "(", ")", ".", "RegInternalErrors", "(", ")", "\n", "}" ]

[ "All", "sets", "this", "listener", "up", "to", "listen", "to", "all", "account", "events", "." ]

[ "func", "ParseTransaction", "(", "trits", "Trits", ",", "noHash", "...", "bool", ")", "(", "*", "Transaction", ",", "error", ")", "{", "var", "err", "error", "\n\n", "if", "len", "(", "trits", ")", "!=", "TransactionTrinarySize", "{", "return", "nil", ",", "ErrInvalidTransaction", "\n", "}", "\n\n", "if", "err", ":=", "ValidTrits", "(", "trits", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "t", ":=", "&", "Transaction", "{", "}", "\n", "t", ".", "SignatureMessageFragment", "=", "MustTritsToTrytes", "(", "trits", "[", "SignatureMessageFragmentTrinaryOffset", ":", "SignatureMessageFragmentTrinarySize", "]", ")", "\n", "t", ".", "Address", ",", "err", "=", "TritsToTrytes", "(", "trits", "[", "AddressTrinaryOffset", ":", "AddressTrinaryOffset", "+", "AddressTrinarySize", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "t", ".", "Value", "=", "TritsToInt", "(", "trits", "[", "ValueOffsetTrinary", ":", "ValueOffsetTrinary", "+", "ValueSizeTrinary", "]", ")", "\n", "t", ".", "ObsoleteTag", "=", "MustTritsToTrytes", "(", "trits", "[", "ObsoleteTagTrinaryOffset", ":", "ObsoleteTagTrinaryOffset", "+", "ObsoleteTagTrinarySize", "]", ")", "\n", "t", ".", "Timestamp", "=", "uint64", "(", "TritsToInt", "(", "trits", "[", "TimestampTrinaryOffset", ":", "TimestampTrinaryOffset", "+", "TimestampTrinarySize", "]", ")", ")", "\n", "t", ".", "CurrentIndex", "=", "uint64", "(", "TritsToInt", "(", "trits", "[", "CurrentIndexTrinaryOffset", ":", "CurrentIndexTrinaryOffset", "+", "CurrentIndexTrinarySize", "]", ")", ")", "\n", "t", ".", "LastIndex", "=", "uint64", "(", "TritsToInt", "(", "trits", "[", "LastIndexTrinaryOffset", ":", "LastIndexTrinaryOffset", "+", "LastIndexTrinarySize", "]", ")", ")", "\n", "if", "t", ".", "CurrentIndex", ">", "t", ".", "LastIndex", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "ErrInvalidIndex", ",", "\"", "\"", ")", "\n", "}", "\n", "t", ".", "Bundle", "=", "MustTritsToTrytes", "(", "trits", "[", "BundleTrinaryOffset", ":", "BundleTrinaryOffset", "+", "BundleTrinarySize", "]", ")", "\n", "t", ".", "TrunkTransaction", "=", "MustTritsToTrytes", "(", "trits", "[", "TrunkTransactionTrinaryOffset", ":", "TrunkTransactionTrinaryOffset", "+", "TrunkTransactionTrinarySize", "]", ")", "\n", "t", ".", "BranchTransaction", "=", "MustTritsToTrytes", "(", "trits", "[", "BranchTransactionTrinaryOffset", ":", "BranchTransactionTrinaryOffset", "+", "BranchTransactionTrinarySize", "]", ")", "\n", "t", ".", "Tag", "=", "MustTritsToTrytes", "(", "trits", "[", "TagTrinaryOffset", ":", "TagTrinaryOffset", "+", "TagTrinarySize", "]", ")", "\n", "t", ".", "AttachmentTimestamp", "=", "TritsToInt", "(", "trits", "[", "AttachmentTimestampTrinaryOffset", ":", "AttachmentTimestampTrinaryOffset", "+", "AttachmentTimestampTrinarySize", "]", ")", "\n", "t", ".", "AttachmentTimestampLowerBound", "=", "TritsToInt", "(", "trits", "[", "AttachmentTimestampLowerBoundTrinaryOffset", ":", "AttachmentTimestampLowerBoundTrinaryOffset", "+", "AttachmentTimestampLowerBoundTrinarySize", "]", ")", "\n", "t", ".", "AttachmentTimestampUpperBound", "=", "TritsToInt", "(", "trits", "[", "AttachmentTimestampUpperBoundTrinaryOffset", ":", "AttachmentTimestampUpperBoundTrinaryOffset", "+", "AttachmentTimestampUpperBoundTrinarySize", "]", ")", "\n", "t", ".", "Nonce", "=", "MustTritsToTrytes", "(", "trits", "[", "NonceTrinaryOffset", ":", "NonceTrinaryOffset", "+", "NonceTrinarySize", "]", ")", "\n", "if", "len", "(", "noHash", ")", "==", "0", "||", "noHash", "[", "0", "]", "==", "false", "{", "t", ".", "Hash", "=", "TransactionHash", "(", "t", ")", "\n", "}", "\n\n", "return", "t", ",", "nil", "\n", "}" ]

[ "ParseTransaction", "parses", "the", "trits", "and", "returns", "a", "transaction", "object", ".", "The", "trits", "slice", "must", "be", "TransactionTrinarySize", "in", "length", ".", "If", "noHash", "is", "set", "to", "true", "no", "transaction", "hash", "is", "calculated", "." ]

[ "func", "ValidTransactionTrytes", "(", "trytes", "Trytes", ")", "error", "{", "// verifies length and trytes values", "if", "!", "guards", ".", "IsTrytesOfExactLength", "(", "trytes", ",", "TransactionTrytesSize", ")", "{", "return", "ErrInvalidTrytes", "\n", "}", "\n\n", "if", "trytes", "[", "2279", ":", "2295", "]", "!=", "\"", "\"", "{", "return", "ErrInvalidTrytes", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ValidTransactionTrytes", "checks", "whether", "the", "given", "trytes", "make", "up", "a", "valid", "transaction", "schematically", "." ]

[ "func", "AsTransactionObject", "(", "trytes", "Trytes", ",", "hash", "...", "Hash", ")", "(", "*", "Transaction", ",", "error", ")", "{", "var", "tx", "*", "Transaction", "\n", "var", "err", "error", "\n\n", "if", "err", ":=", "ValidTransactionTrytes", "(", "trytes", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "skipHashCalc", ":=", "len", "(", "hash", ")", ">", "0", "\n", "if", "tx", ",", "err", "=", "ParseTransaction", "(", "MustTrytesToTrits", "(", "trytes", ")", ",", "skipHashCalc", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "skipHashCalc", "{", "tx", ".", "Hash", "=", "hash", "[", "0", "]", "\n", "}", "\n\n", "return", "tx", ",", "nil", "\n", "}" ]

[ "AsTransactionObject", "makes", "a", "new", "transaction", "from", "the", "given", "trytes", ".", "Optionally", "the", "computed", "transaction", "hash", "can", "be", "overwritten", "by", "supplying", "an", "own", "hash", "." ]

[ "func", "AsTransactionObjects", "(", "rawTrytes", "[", "]", "Trytes", ",", "hashes", "Hashes", ")", "(", "Transactions", ",", "error", ")", "{", "txs", ":=", "make", "(", "Transactions", ",", "len", "(", "rawTrytes", ")", ")", "\n", "var", "tx", "*", "Transaction", "\n", "var", "err", "error", "\n", "for", "i", ":=", "range", "rawTrytes", "{", "if", "hashes", "!=", "nil", "&&", "len", "(", "hashes", ")", ">", "0", "&&", "len", "(", "hashes", ")", ">", "i", "{", "tx", ",", "err", "=", "AsTransactionObject", "(", "rawTrytes", "[", "i", "]", ",", "hashes", "[", "i", "]", ")", "\n", "}", "else", "{", "tx", ",", "err", "=", "AsTransactionObject", "(", "rawTrytes", "[", "i", "]", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "txs", "[", "i", "]", "=", "*", "tx", "\n", "}", "\n", "return", "txs", ",", "nil", "\n", "}" ]

[ "AsTransactionObjects", "constructs", "new", "transactions", "from", "the", "given", "raw", "trytes", "." ]

[ "func", "MustTransactionToTrytes", "(", "t", "*", "Transaction", ")", "Trytes", "{", "trytes", ",", "err", ":=", "TransactionToTrytes", "(", "t", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "trytes", "\n", "}" ]

[ "MustTransactionToTrytes", "converts", "the", "transaction", "to", "trytes", "." ]

[ "func", "TransactionsToTrytes", "(", "txs", "Transactions", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "trytes", ":=", "make", "(", "[", "]", "Trytes", ",", "len", "(", "txs", ")", ")", "\n", "var", "err", "error", "\n", "for", "i", ":=", "range", "txs", "{", "trytes", "[", "i", "]", ",", "err", "=", "TransactionToTrytes", "(", "&", "txs", "[", "i", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "trytes", ",", "nil", "\n", "}" ]

[ "TransactionsToTrytes", "returns", "a", "slice", "of", "transaction", "trytes", "from", "the", "given", "transactions", "." ]

[ "func", "MustTransactionsToTrytes", "(", "txs", "Transactions", ")", "[", "]", "Trytes", "{", "trytes", ":=", "make", "(", "[", "]", "Trytes", ",", "len", "(", "txs", ")", ")", "\n", "for", "i", ":=", "range", "txs", "{", "trytes", "[", "i", "]", "=", "MustTransactionToTrytes", "(", "&", "txs", "[", "i", "]", ")", "\n", "}", "\n", "return", "trytes", "\n", "}" ]

[ "MustTransactionsToTrytes", "returns", "a", "slice", "of", "transaction", "trytes", "from", "the", "given", "transactions", "." ]

[ "func", "FinalTransactionTrytes", "(", "txs", "Transactions", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "trytes", ",", "err", ":=", "TransactionsToTrytes", "(", "txs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "i", ",", "j", ":=", "0", ",", "len", "(", "trytes", ")", "-", "1", ";", "i", "<", "j", ";", "i", ",", "j", "=", "i", "+", "1", ",", "j", "-", "1", "{", "trytes", "[", "i", "]", ",", "trytes", "[", "j", "]", "=", "trytes", "[", "j", "]", ",", "trytes", "[", "i", "]", "\n", "}", "\n", "return", "trytes", ",", "nil", "\n", "}" ]

[ "FinalTransactionTrytes", "returns", "a", "slice", "of", "transaction", "trytes", "from", "the", "given", "transactions", ".", "The", "order", "of", "the", "transactions", "is", "reversed", "in", "the", "output", "slice", "." ]

[ "func", "MustFinalTransactionTrytes", "(", "txs", "Transactions", ")", "[", "]", "Trytes", "{", "trytes", ":=", "MustTransactionsToTrytes", "(", "txs", ")", "\n", "for", "i", ",", "j", ":=", "0", ",", "len", "(", "trytes", ")", "-", "1", ";", "i", "<", "j", ";", "i", ",", "j", "=", "i", "+", "1", ",", "j", "-", "1", "{", "trytes", "[", "i", "]", ",", "trytes", "[", "j", "]", "=", "trytes", "[", "j", "]", ",", "trytes", "[", "i", "]", "\n", "}", "\n", "return", "trytes", "\n", "}" ]

[ "MustFinalTransactionTrytes", "returns", "a", "slice", "of", "transaction", "trytes", "from", "the", "given", "transactions", ".", "The", "order", "of", "the", "transactions", "is", "reversed", "in", "the", "output", "slice", "." ]

[ "func", "HasValidNonce", "(", "t", "*", "Transaction", ",", "mwm", "uint64", ")", "bool", "{", "return", "TrailingZeros", "(", "MustTrytesToTrits", "(", "TransactionHash", "(", "t", ")", ")", ")", ">=", "int64", "(", "mwm", ")", "\n", "}" ]

[ "HasValidNonce", "checks", "if", "the", "transaction", "has", "the", "valid", "MinWeightMagnitude", ".", "MWM", "corresponds", "to", "the", "amount", "of", "zero", "trits", "at", "the", "end", "of", "the", "transaction", "hash", "." ]

[ "func", "MerkleDepth", "(", "nodeCount", "uint64", ")", "(", "depth", "uint64", ")", "{", "depth", "=", "0", "\n\n", "for", "binaryTreeSize", "(", "0", ",", "depth", ")", "<", "nodeCount", "{", "depth", "++", "\n", "}", "\n\n", "return", "depth", "+", "1", "\n", "}" ]

[ "MerkleDepth", "computes", "the", "depth", "of", "a", "merkle", "tree", ".", "nodeCount", "is", "the", "number", "of", "nodes", "of", "the", "tree" ]

[ "func", "merkleNodeIndexTraverse", "(", "acc", ",", "depth", ",", "width", ",", "treeDepth", "uint64", ")", "uint64", "{", "if", "treeDepth", "==", "0", "{", "return", "0", "\n", "}", "\n\n", "var", "depthCursor", "uint64", "=", "1", "\n", "index", ":=", "depth", "+", "acc", "\n", "widthCursor", ":=", "width", "\n", "var", "widthOfLeaves", "uint64", "=", "1", "<<", "depth", "\n\n", "for", "depthCursor", "<=", "depth", "{", "if", "widthCursor", ">=", "(", "widthOfLeaves", ">>", "depthCursor", ")", "{", "// add whole binary tree size of the left side binary tree", "index", "+=", "(", "(", "1", "<<", "(", "treeDepth", "-", "depthCursor", "+", "1", ")", ")", "-", "1", ")", "\n\n", "// counting the node index of the subtree in which the cursor currently stays in", "widthCursor", "=", "widthCursor", "-", "(", "widthOfLeaves", ">>", "depthCursor", ")", "\n", "}", "\n", "depthCursor", "++", "\n", "}", "\n", "return", "index", "\n", "}" ]

[ "merkleNodeIndexTraverse", "returns", "the", "node", "index", "of", "assign", "location", "in", "tree", ".", "The", "order", "of", "nodes", "indexes", "follow", "depth", "-", "first", "rule", ".", "acc", "is", "the", "number", "of", "nodes", "in", "the", "previous", "counting", "binary", "tree", "depth", "is", "the", "depth", "of", "the", "node", "counting", "from", "root", "width", "is", "the", "width", "of", "the", "node", "counting", "from", "left", "treeDepth", "is", "the", "depth", "of", "whole", "tree" ]

[ "func", "MerkleNodeIndex", "(", "depth", ",", "width", ",", "treeDepth", "uint64", ")", "uint64", "{", "return", "merkleNodeIndexTraverse", "(", "0", ",", "depth", ",", "width", ",", "treeDepth", ")", "\n", "}" ]

[ "MerkleNodeIndex", "indexes", "a", "given", "node", "in", "the", "tree", ".", "depth", "is", "the", "depth", "of", "the", "node", "counting", "from", "root", "width", "is", "the", "width", "of", "the", "node", "counting", "from", "left", "treeDepth", "is", "the", "depth", "of", "whole", "tree" ]

[ "func", "MerkleBranch", "(", "tree", "Trits", ",", "siblings", "Trits", ",", "treeLength", ",", "treeDepth", ",", "leafIndex", ",", "leafCount", "uint64", ")", "(", "Trits", ",", "error", ")", "{", "if", "tree", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "siblings", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "HashTrinarySize", "*", "MerkleNodeIndex", "(", "treeDepth", "-", "1", ",", "leafIndex", ",", "treeDepth", "-", "1", ")", ">=", "treeLength", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "treeDepth", ">", "MerkleDepth", "(", "treeLength", "/", "HashTrinarySize", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "siblingIndex", ",", "siteIndex", "uint64", "\n\n", "siblingIndex", "=", "MerkleLeafIndex", "(", "leafIndex", ",", "leafCount", ")", "\n\n", "var", "i", "int64", "=", "0", "\n", "for", "depthIndex", ":=", "treeDepth", "-", "1", ";", "depthIndex", ">", "0", ";", "depthIndex", "--", "{", "if", "(", "siblingIndex", "&", "1", ")", "!=", "0", "{", "siblingIndex", "--", "\n", "}", "else", "{", "siblingIndex", "++", "\n", "}", "\n\n", "siteIndex", "=", "HashTrinarySize", "*", "MerkleNodeIndex", "(", "depthIndex", ",", "siblingIndex", ",", "treeDepth", "-", "1", ")", "\n", "if", "siteIndex", ">=", "treeLength", "{", "// if depth width is not even, copy a null hash", "copy", "(", "siblings", "[", "i", "*", "HashTrinarySize", ":", "(", "i", "+", "1", ")", "*", "HashTrinarySize", "]", ",", "merkleNullHash", ")", "\n", "}", "else", "{", "// else copy a sibling", "copy", "(", "siblings", "[", "i", "*", "HashTrinarySize", ":", "(", "i", "+", "1", ")", "*", "HashTrinarySize", "]", ",", "tree", "[", "siteIndex", ":", "siteIndex", "+", "HashTrinarySize", "]", ")", "\n", "}", "\n\n", "siblingIndex", ">>=", "1", "\n", "i", "++", "\n", "}", "\n", "return", "siblings", ",", "nil", "\n", "}" ]

[ "MerkleBranch", "creates", "the", "merkle", "branch", "to", "generate", "back", "root", "from", "index", ".", "tree", "is", "the", "merkle", "tree", "-", "Must", "be", "allocated", "siblings", "is", "the", "siblings", "of", "the", "indexed", "node", "-", "Must", "be", "allocated", "treeLength", "is", "the", "length", "of", "the", "tree", "treeDepth", "is", "the", "depth", "of", "the", "tree", "leafIndex", "is", "the", "index", "of", "the", "leaf", "to", "start", "the", "branch", "from", "leafCount", "is", "the", "number", "of", "leaves", "of", "the", "tree" ]