Datasets:

CM

/

codexglue_code2text_go

like 1

[ "func", "MerkleRoot", "(", "hash", "Trits", ",", "siblings", "Trits", ",", "siblingsNumber", "uint64", ",", "leafIndex", "uint64", ",", "spongeFunc", "...", "sponge", ".", "SpongeFunction", ")", "(", "Trits", ",", "error", ")", "{", "h", ":=", "sponge", ".", "GetSpongeFunc", "(", "spongeFunc", ",", "curl", ".", "NewCurlP27", ")", "\n\n", "var", "j", "uint64", "=", "1", "\n", "var", "err", "error", "\n\n", "for", "i", ":=", "uint64", "(", "0", ")", ";", "i", "<", "siblingsNumber", ";", "i", "++", "{", "siblingsIdx", ":=", "i", "*", "HashTrinarySize", "\n\n", "if", "(", "leafIndex", "&", "j", ")", "!=", "0", "{", "// if index is a right node, absorb a sibling (left) then the hash", "err", "=", "h", ".", "Absorb", "(", "siblings", "[", "siblingsIdx", ":", "siblingsIdx", "+", "HashTrinarySize", "]", ")", "\n", "err", "=", "h", ".", "Absorb", "(", "hash", ")", "\n", "}", "else", "{", "// if index is a left node, absorb the hash then a sibling (right)", "err", "=", "h", ".", "Absorb", "(", "hash", ")", "\n", "err", "=", "h", ".", "Absorb", "(", "siblings", "[", "siblingsIdx", ":", "siblingsIdx", "+", "HashTrinarySize", "]", ")", "\n", "}", "\n\n", "hash", ",", "err", "=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "h", ".", "Reset", "(", ")", "\n\n", "j", "<<=", "1", "\n", "}", "\n", "return", "hash", ",", "err", "\n", "}" ]

[ "MerkleRoot", "generates", "a", "merkle", "root", "from", "a", "hash", "and", "his", "siblings", "hash", "is", "the", "hash", "siblings", "is", "the", "hash", "siblings", "siblingsNumber", "is", "the", "number", "of", "siblings", "leafIndex", "is", "the", "node", "index", "of", "the", "hash", "spongeFunc", "is", "the", "optional", "sponge", "function", "to", "use" ]

[ "func", "DoPoW", "(", "trunkTx", "Trytes", ",", "branchTx", "Trytes", ",", "trytes", "[", "]", "Trytes", ",", "mwm", "uint64", ",", "pow", "ProofOfWorkFunc", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "txs", ",", "err", ":=", "AsTransactionObjects", "(", "trytes", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "prev", "Trytes", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "txs", ")", ";", "i", "++", "{", "switch", "{", "case", "i", "==", "0", ":", "txs", "[", "i", "]", ".", "TrunkTransaction", "=", "trunkTx", "\n", "txs", "[", "i", "]", ".", "BranchTransaction", "=", "branchTx", "\n", "default", ":", "txs", "[", "i", "]", ".", "TrunkTransaction", "=", "prev", "\n", "txs", "[", "i", "]", ".", "BranchTransaction", "=", "trunkTx", "\n", "}", "\n\n", "txs", "[", "i", "]", ".", "AttachmentTimestamp", "=", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", "/", "1000000", "\n", "txs", "[", "i", "]", ".", "AttachmentTimestampLowerBound", "=", "LowerBoundAttachmentTimestamp", "\n", "txs", "[", "i", "]", ".", "AttachmentTimestampUpperBound", "=", "UpperBoundAttachmentTimestamp", "\n\n", "var", "err", "error", "\n", "txs", "[", "i", "]", ".", "Nonce", ",", "err", "=", "pow", "(", "MustTransactionToTrytes", "(", "&", "txs", "[", "i", "]", ")", ",", "int", "(", "mwm", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// set new transaction hash", "txs", "[", "i", "]", ".", "Hash", "=", "TransactionHash", "(", "&", "txs", "[", "i", "]", ")", "\n", "prev", "=", "txs", "[", "i", "]", ".", "Hash", "\n", "}", "\n", "powedTxTrytes", ":=", "MustTransactionsToTrytes", "(", "txs", ")", "\n", "for", "left", ",", "right", ":=", "0", ",", "len", "(", "powedTxTrytes", ")", "-", "1", ";", "left", "<", "right", ";", "left", ",", "right", "=", "left", "+", "1", ",", "right", "-", "1", "{", "powedTxTrytes", "[", "left", "]", ",", "powedTxTrytes", "[", "right", "]", "=", "powedTxTrytes", "[", "right", "]", ",", "powedTxTrytes", "[", "left", "]", "\n", "}", "\n", "return", "powedTxTrytes", ",", "nil", "\n", "}" ]

[ "DoPoW", "computes", "the", "nonce", "field", "for", "each", "transaction", "so", "that", "the", "last", "MWM", "-", "length", "trits", "of", "the", "transaction", "hash", "are", "all", "zeroes", ".", "Starting", "from", "the", "0", "index", "transaction", "the", "transactions", "get", "chained", "to", "each", "other", "through", "the", "trunk", "transaction", "hash", "field", ".", "The", "last", "transaction", "in", "the", "bundle", "approves", "the", "given", "branch", "and", "trunk", "transactions", ".", "This", "function", "also", "initializes", "the", "attachment", "timestamp", "fields", ".", "This", "function", "expects", "the", "passed", "in", "transaction", "trytes", "from", "highest", "to", "lowest", "index", "meaning", "the", "transaction", "with", "current", "index", "0", "at", "the", "last", "position", "." ]

[ "func", "GetProofOfWorkImpl", "(", "name", "string", ")", "(", "ProofOfWorkFunc", ",", "error", ")", "{", "if", "p", ",", "exist", ":=", "proofOfWorkFuncs", "[", "name", "]", ";", "exist", "{", "return", "p", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "errors", ".", "Wrapf", "(", "ErrUnknownProofOfWorkFunc", ",", "\"", "\"", ",", "name", ")", "\n", "}" ]

[ "GetProofOfWorkImpl", "returns", "the", "specified", "Proof", "-", "of", "-", "Work", "implementation", "given", "a", "name", "." ]

[ "func", "GetProofOfWorkImplementations", "(", ")", "[", "]", "string", "{", "powFuncNames", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "proofOfWorkFuncs", ")", ")", "\n\n", "i", ":=", "0", "\n", "for", "k", ":=", "range", "proofOfWorkFuncs", "{", "powFuncNames", "[", "i", "]", "=", "k", "\n", "i", "++", "\n", "}", "\n\n", "return", "powFuncNames", "\n", "}" ]

[ "GetProofOfWorkImplementations", "returns", "an", "array", "with", "the", "names", "of", "all", "available", "Proof", "-", "of", "-", "Work", "implementations", "." ]

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

[ "GoProofOfWork", "does", "Proof", "-", "of", "-", "Work", "on", "the", "given", "trytes", "using", "only", "Go", "code", "." ]

[ "func", "Loop", "(", "lmid", "*", "[", "curl", ".", "StateSize", "]", "uint64", ",", "hmid", "*", "[", "curl", ".", "StateSize", "]", "uint64", ",", "m", "int", ",", "cancelled", "*", "bool", ",", "checkFun", "CheckFunc", ",", "loopCnt", "int", ")", "(", "nonce", "Trits", ",", "rate", "int64", ",", "foundIndex", "int", ")", "{", "var", "lcpy", ",", "hcpy", "[", "curl", ".", "StateSize", "]", "uint64", "\n", "var", "i", "int64", "\n\n", "for", "i", "=", "0", ";", "!", "*", "cancelled", ";", "i", "++", "{", "copy", "(", "lcpy", "[", ":", "]", ",", "lmid", "[", ":", "]", ")", "\n", "copy", "(", "hcpy", "[", ":", "]", ",", "hmid", "[", ":", "]", ")", "\n", "transform64", "(", "&", "lcpy", ",", "&", "hcpy", ",", "loopCnt", ")", "\n\n", "if", "n", ":=", "checkFun", "(", "&", "lcpy", ",", "&", "hcpy", ",", "m", ")", ";", "n", ">=", "0", "{", "nonce", ":=", "seri", "(", "lmid", ",", "hmid", ",", "uint", "(", "n", ")", ")", "\n", "return", "nonce", ",", "i", "*", "64", ",", "n", "\n", "}", "\n", "incr", "(", "lmid", ",", "hmid", ")", "\n", "}", "\n", "return", "nil", ",", "i", "*", "64", ",", "-", "1", "\n", "}" ]

[ "Loop", "increments", "and", "transforms", "until", "checkFun", "is", "true", "." ]

[ "func", "goProofOfWork", "(", "trytes", "Trytes", ",", "mwm", "int", ",", "optRate", "chan", "int64", ",", "parallelism", "...", "int", ")", "(", "Trytes", ",", "error", ")", "{", "if", "trytes", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "ErrInvalidTrytesForProofOfWork", "\n", "}", "\n\n", "// if any goroutine finds a nonce, then the cancel flag is set to true", "// and thereby all other ongoing Proof-of-Work tasks will halt.", "cancelled", ":=", "false", "\n\n", "tr", ":=", "MustTrytesToTrits", "(", "trytes", ")", "\n\n", "c", ":=", "curl", ".", "NewCurlP81", "(", ")", ".", "(", "*", "curl", ".", "Curl", ")", "\n", "c", ".", "Absorb", "(", "tr", "[", ":", "(", "TransactionTrinarySize", "-", "HashTrinarySize", ")", "]", ")", "\n", "copy", "(", "c", ".", "State", ",", "tr", "[", "TransactionTrinarySize", "-", "HashTrinarySize", ":", "]", ")", "\n\n", "numGoroutines", ":=", "proofOfWorkParallelism", "(", "parallelism", "...", ")", "\n", "var", "result", "Trytes", "\n", "var", "rate", "chan", "int64", "\n", "if", "optRate", "!=", "nil", "{", "rate", "=", "make", "(", "chan", "int64", ",", "numGoroutines", ")", "\n", "}", "\n", "exit", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "nonceChan", ":=", "make", "(", "chan", "Trytes", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "numGoroutines", ";", "i", "++", "{", "go", "func", "(", "i", "int", ")", "{", "lmid", ",", "hmid", ":=", "Para", "(", "c", ".", "State", ")", "\n", "lmid", "[", "nonceOffset", "]", "=", "PearlDiverMidStateLow0", "\n", "hmid", "[", "nonceOffset", "]", "=", "PearlDiverMidStateHigh0", "\n", "lmid", "[", "nonceOffset", "+", "1", "]", "=", "PearlDiverMidStateLow1", "\n", "hmid", "[", "nonceOffset", "+", "1", "]", "=", "PearlDiverMidStateHigh1", "\n", "lmid", "[", "nonceOffset", "+", "2", "]", "=", "PearlDiverMidStateLow2", "\n", "hmid", "[", "nonceOffset", "+", "2", "]", "=", "PearlDiverMidStateHigh2", "\n", "lmid", "[", "nonceOffset", "+", "3", "]", "=", "PearlDiverMidStateLow3", "\n", "hmid", "[", "nonceOffset", "+", "3", "]", "=", "PearlDiverMidStateHigh3", "\n\n", "incrN", "(", "i", ",", "lmid", ",", "hmid", ")", "\n", "nonce", ",", "r", ",", "_", ":=", "Loop", "(", "lmid", ",", "hmid", ",", "mwm", ",", "&", "cancelled", ",", "check", ",", "int", "(", "c", ".", "Rounds", ")", ")", "\n\n", "if", "rate", "!=", "nil", "{", "rate", "<-", "int64", "(", "math", ".", "Abs", "(", "float64", "(", "r", ")", ")", ")", "\n", "}", "\n", "if", "r", ">=", "0", "&&", "len", "(", "nonce", ")", ">", "0", "{", "select", "{", "case", "<-", "exit", ":", "case", "nonceChan", "<-", "MustTritsToTrytes", "(", "nonce", ")", ":", "cancelled", "=", "true", "\n", "}", "\n", "}", "\n", "}", "(", "i", ")", "\n", "}", "\n\n", "if", "rate", "!=", "nil", "{", "var", "rateSum", "int64", "\n", "for", "i", ":=", "0", ";", "i", "<", "numGoroutines", ";", "i", "++", "{", "rateSum", "+=", "<-", "rate", "\n", "}", "\n", "optRate", "<-", "rateSum", "\n", "}", "\n\n", "result", "=", "<-", "nonceChan", "\n", "close", "(", "exit", ")", "\n", "cancelled", "=", "true", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "implementation", "of", "Proof", "-", "of", "-", "Work", "in", "Go" ]

[ "func", "(", "dc", "*", "CDA", ")", "AsMagnetLink", "(", ")", "(", "string", ",", "error", ")", "{", "var", "expectedAmount", "uint64", "\n", "if", "dc", ".", "ExpectedAmount", "!=", "nil", "{", "expectedAmount", "=", "*", "dc", ".", "ExpectedAmount", "\n", "}", "\n", "checksum", ",", "err", ":=", "dc", ".", "Checksum", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "var", "multiUse", "int", "\n", "if", "dc", ".", "MultiUse", "{", "multiUse", "=", "1", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "MagnetLinkFormat", ",", "dc", ".", "Address", "[", ":", "consts", ".", "HashTrytesSize", "]", ",", "checksum", "[", "consts", ".", "HashTrytesSize", "-", "consts", ".", "AddressChecksumTrytesSize", ":", "consts", ".", "HashTrytesSize", "]", ",", "MagnetLinkTimeoutField", ",", "dc", ".", "TimeoutAt", ".", "Unix", "(", ")", ",", "MagnetLinkMultiUseField", ",", "multiUse", ",", "MagnetLinkExpectedAmountField", ",", "expectedAmount", ")", ",", "nil", "\n", "}" ]

[ "AsMagnetLink", "converts", "the", "conditions", "into", "a", "magnet", "link", "URL", "." ]

[ "func", "(", "dc", "*", "CDA", ")", "AsTransfer", "(", ")", "bundle", ".", "Transfer", "{", "return", "bundle", ".", "Transfer", "{", "Address", ":", "dc", ".", "Address", ",", "Value", ":", "func", "(", ")", "uint64", "{", "if", "dc", ".", "ExpectedAmount", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "*", "dc", ".", "ExpectedAmount", "\n", "}", "(", ")", ",", "}", "\n", "}" ]

[ "AsTransfer", "converts", "the", "conditional", "deposit", "address", "into", "a", "transfer", "object", "." ]

[ "func", "(", "dc", "*", "CDA", ")", "Checksum", "(", ")", "(", "Trytes", ",", "error", ")", "{", "// checksum formula:", "// Checksum = CurlHash(", "// \tCurlHash(address_trits)[:134] +", "// \tPadTrits27(timeout_value_trits) +", "// \tMultiUse(0/1) +", "// \tPadTrits81(amount_value_trits)", "// )", "if", "err", ":=", "ValidateConditions", "(", "&", "dc", ".", "Conditions", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "addrTrits", ",", "err", ":=", "TrytesToTrits", "(", "dc", ".", "Address", "[", ":", "consts", ".", "HashTrytesSize", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "c", ":=", "curl", ".", "NewCurlP81", "(", ")", "\n", "if", "err", ":=", "c", ".", "Absorb", "(", "addrTrits", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "addrChecksumTrits", ",", "err", ":=", "c", ".", "Squeeze", "(", "consts", ".", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "timeoutAtTrits", ":=", "PadTrits", "(", "IntToTrits", "(", "dc", ".", "TimeoutAt", ".", "Unix", "(", ")", ")", ",", "27", ")", "\n", "var", "expectedAmountTrits", "Trits", "\n", "if", "dc", ".", "ExpectedAmount", "!=", "nil", "{", "expectedAmountTrits", "=", "PadTrits", "(", "IntToTrits", "(", "int64", "(", "*", "dc", ".", "ExpectedAmount", ")", ")", ",", "81", ")", "\n", "}", "else", "{", "expectedAmountTrits", "=", "PadTrits", "(", "expectedAmountTrits", ",", "81", ")", "\n", "}", "\n", "var", "multiUse", "int8", "\n", "if", "dc", ".", "MultiUse", "{", "multiUse", "=", "1", "\n", "}", "\n", "input", ":=", "make", "(", "Trits", ",", "0", ")", "\n", "input", "=", "append", "(", "input", ",", "addrChecksumTrits", "[", ":", "134", "]", "...", ")", "\n", "input", "=", "append", "(", "input", ",", "timeoutAtTrits", "...", ")", "\n", "input", "=", "append", "(", "input", ",", "multiUse", ")", "\n", "input", "=", "append", "(", "input", ",", "expectedAmountTrits", "...", ")", "\n", "c", ".", "Reset", "(", ")", "\n", "if", "err", ":=", "c", ".", "Absorb", "(", "input", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "checksumTrits", ",", "err", ":=", "c", ".", "Squeeze", "(", "consts", ".", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "TritsToTrytes", "(", "checksumTrits", ")", "\n", "}" ]

[ "Checksum", "returns", "the", "checksum", "of", "the", "the", "CDA", "." ]

[ "func", "ParseMagnetLink", "(", "cdaMagnetLink", "string", ")", "(", "*", "CDA", ",", "error", ")", "{", "link", ",", "err", ":=", "url", ".", "Parse", "(", "cdaMagnetLink", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "query", ":=", "link", ".", "Query", "(", ")", "\n", "cda", ":=", "&", "CDA", "{", "}", "\n", "if", "len", "(", "link", ".", "Host", ")", "!=", "consts", ".", "AddressWithChecksumTrytesSize", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "ErrAddressInvalid", ",", "\"", "\"", ")", "\n", "}", "\n", "addrWithChecksum", ",", "err", ":=", "checksum", ".", "AddChecksum", "(", "link", ".", "Host", "[", ":", "consts", ".", "HashTrytesSize", "]", ",", "true", ",", "consts", ".", "AddressChecksumTrytesSize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cda", ".", "Address", "=", "addrWithChecksum", "\n", "expiresSeconds", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "query", ".", "Get", "(", "MagnetLinkTimeoutField", ")", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "expire", ":=", "time", ".", "Unix", "(", "expiresSeconds", ",", "0", ")", ".", "UTC", "(", ")", "\n", "cda", ".", "TimeoutAt", "=", "&", "expire", "\n", "cda", ".", "MultiUse", "=", "query", ".", "Get", "(", "MagnetLinkMultiUseField", ")", "==", "\"", "\"", "\n", "expectedAmount", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "query", ".", "Get", "(", "MagnetLinkExpectedAmountField", ")", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "cda", ".", "ExpectedAmount", "=", "&", "expectedAmount", "\n\n", "computedChecksum", ",", "err", ":=", "cda", ".", "Checksum", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "magnetLinkChecksum", ":=", "link", ".", "Host", "[", "consts", ".", "HashTrytesSize", ":", "]", "\n", "if", "computedChecksum", "[", "consts", ".", "HashTrytesSize", "-", "consts", ".", "AddressChecksumTrytesSize", ":", "consts", ".", "HashTrytesSize", "]", "!=", "magnetLinkChecksum", "{", "return", "nil", ",", "ErrMagnetLinkChecksumInvalid", "\n", "}", "\n", "if", "err", ":=", "ValidateConditions", "(", "&", "cda", ".", "Conditions", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "cda", ",", "nil", "\n", "}" ]

[ "ParseMagnetLink", "parses", "the", "given", "magnet", "link", "URL", "." ]

[ "func", "ValidateConditions", "(", "conds", "*", "Conditions", ")", "error", "{", "if", "conds", ".", "ExpectedAmount", "!=", "nil", "{", "if", "*", "conds", ".", "ExpectedAmount", ">", "0", "&&", "conds", ".", "MultiUse", "{", "return", "errors", ".", "Wrap", "(", "ErrInvalidDepositAddressOptions", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateConditions", "validates", "the", "deposit", "conditions", "." ]

[ "func", "IsAttachedTrytes", "(", "trytes", "Trytes", ")", "bool", "{", "return", "IsTrytesOfExactLength", "(", "trytes", ",", "TransactionTrytesSize", ")", "&&", "!", "IsEmptyTrytes", "(", "trytes", "[", "(", "TransactionTrytesSize", ")", "-", "3", "*", "HashTrytesSize", ":", "]", ")", "\n", "}" ]

[ "IsAttachedTrytes", "checks", "if", "input", "is", "valid", "attached", "transaction", "trytes", ".", "For", "attached", "transactions", "the", "last", "243", "trytes", "are", "non", "-", "zero", "." ]

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

[ "SSEProofOfWork", "does", "proof", "of", "work", "on", "the", "given", "trytes", "using", "SSE2", "instructions", "." ]

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

[ "NewCallbackEventListener", "creates", "a", "new", "CallbackEventListener", "using", "the", "given", "EventMachine", "." ]

[ "func", "(", "el", "*", "CallbackEventListener", ")", "RegPromotions", "(", "f", "PromotionReattachmentEventCallback", ")", "{", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "f", "(", "data", ".", "(", "*", "promoter", ".", "PromotionReattachmentEvent", ")", ")", "\n", "}", ",", "promoter", ".", "EventPromotion", ")", ")", "\n", "}" ]

[ "RegPromotions", "registers", "the", "given", "callback", "to", "execute", "on", "promotions", "." ]

[ "func", "(", "el", "*", "CallbackEventListener", ")", "RegReattachments", "(", "f", "PromotionReattachmentEventCallback", ")", "{", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "f", "(", "data", ".", "(", "*", "promoter", ".", "PromotionReattachmentEvent", ")", ")", "\n", "}", ",", "promoter", ".", "EventReattachment", ")", ")", "\n", "}" ]

[ "RegReattachments", "registers", "the", "given", "callback", "to", "execute", "on", "reattachments", "." ]

[ "func", "(", "el", "*", "CallbackEventListener", ")", "RegSentTransfers", "(", "f", "BundleEventCallback", ")", "{", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "f", "(", "data", ".", "(", "bundle", ".", "Bundle", ")", ")", "\n", "}", ",", "event", ".", "EventSentTransfer", ")", ")", "\n", "}" ]

[ "RegSentTransfers", "registers", "the", "given", "callback", "to", "execute", "when", "a", "transfer", "is", "sent", "off", "." ]

[ "func", "(", "el", "*", "CallbackEventListener", ")", "RegConfirmedTransfers", "(", "f", "BundleEventCallback", ")", "{", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "f", "(", "data", ".", "(", "bundle", ".", "Bundle", ")", ")", "\n", "}", ",", "poller", ".", "EventTransferConfirmed", ")", ")", "\n", "}" ]

[ "RegConfirmedTransfers", "registers", "the", "given", "callback", "to", "execute", "when", "a", "transfer", "got", "confirmed", "." ]

[ "func", "(", "el", "*", "CallbackEventListener", ")", "RegReceivingDeposits", "(", "f", "BundleEventCallback", ")", "{", "el", ".", "ids", "=", "append", "(", "el", ".", "ids", ",", "el", ".", "em", ".", "RegisterListener", "(", "func", "(", "data", "interface", "{", "}", ")", "{", "f", "(", "data", ".", "(", "bundle", ".", "Bundle", ")", ")", "\n", "}", ",", "poller", ".", "EventReceivingDeposit", ")", ")", "\n", "}" ]

[ "RegReceivingDeposits", "registers", "the", "given", "callback", "to", "execute", "when", "a", "new", "deposit", "is", "being", "received", "." ]

[ "func", "(", "api", "*", "API", ")", "BroadcastBundle", "(", "tailTxHash", "Hash", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateTransactionHashes", "(", "tailTxHash", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "bndl", ",", "err", ":=", "api", ".", "GetBundle", "(", "tailTxHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "trytes", ":=", "transaction", ".", "MustFinalTransactionTrytes", "(", "bndl", ")", "\n", "return", "api", ".", "BroadcastTransactions", "(", "trytes", "...", ")", "\n", "}" ]

[ "BroadcastBundle", "re", "-", "broadcasts", "all", "transactions", "in", "a", "bundle", "given", "the", "tail", "transaction", "hash", ".", "It", "might", "be", "useful", "when", "transactions", "did", "not", "properly", "propagate", "particularly", "in", "the", "case", "of", "large", "bundles", "." ]

[ "func", "(", "api", "*", "API", ")", "GetBundle", "(", "tailTxHash", "Hash", ")", "(", "bundle", ".", "Bundle", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateTransactionHashes", "(", "tailTxHash", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "err", "error", "\n", "bndl", ":=", "bundle", ".", "Bundle", "{", "}", "\n", "bndl", ",", "err", "=", "api", ".", "TraverseBundle", "(", "tailTxHash", ",", "bndl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "bundle", ".", "ValidBundle", "(", "bndl", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "bndl", ",", "err", "\n", "}" ]

[ "GetBundle", "fetches", "and", "validates", "the", "bundle", "given", "a", "tail", "transaction", "hash", "by", "calling", "TraverseBundle", "and", "traversing", "through", "trunk", "transactions", "." ]

[ "func", "(", "api", "*", "API", ")", "GetBundlesFromAddresses", "(", "addresses", "Hashes", ",", "inclusionState", "...", "bool", ")", "(", "bundle", ".", "Bundles", ",", "error", ")", "{", "txs", ",", "err", ":=", "api", ".", "FindTransactionObjects", "(", "FindTransactionsQuery", "{", "Addresses", ":", "addresses", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "txs", ")", "==", "0", "{", "return", "bundle", ".", "Bundles", "{", "}", ",", "nil", "\n", "}", "\n\n", "// misuse as a set", "bundleHashesSet", ":=", "map", "[", "Hash", "]", "struct", "{", "}", "{", "}", "\n", "for", "i", ":=", "range", "txs", "{", "bundleHashesSet", "[", "txs", "[", "i", "]", ".", "Bundle", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "bundleHashes", ":=", "make", "(", "Hashes", ",", "len", "(", "bundleHashesSet", ")", ")", "\n", "i", ":=", "0", "\n", "for", "hash", ":=", "range", "bundleHashesSet", "{", "bundleHashes", "[", "i", "]", "=", "hash", "\n", "i", "++", "\n", "}", "\n\n", "allTxs", ",", "err", ":=", "api", ".", "FindTransactionObjects", "(", "FindTransactionsQuery", "{", "Bundles", ":", "bundleHashes", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "bundles", ":=", "bundle", ".", "GroupTransactionsIntoBundles", "(", "allTxs", ")", "\n", "sort", ".", "Sort", "(", "bundle", ".", "BundlesByTimestamp", "(", "bundles", ")", ")", "\n\n", "if", "len", "(", "inclusionState", ")", ">", "0", "&&", "inclusionState", "[", "0", "]", "{", "// get tail tx hashes", "hashes", ":=", "make", "(", "Hashes", ",", "len", "(", "bundles", ")", ")", "\n", "for", "i", ":=", "range", "bundles", "{", "hashes", "[", "i", "]", "=", "bundles", "[", "i", "]", "[", "0", "]", ".", "Hash", "\n", "}", "\n\n", "states", ",", "err", ":=", "api", ".", "GetLatestInclusion", "(", "hashes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// set confirmed property on each tx", "// since bundles are atomic, each tx in the bundle", "// as the same 'confirmed' state", "for", "i", ":=", "range", "bundles", "{", "bndl", ":=", "&", "bundles", "[", "i", "]", "\n", "for", "j", ":=", "range", "*", "bndl", "{", "tx", ":=", "&", "(", "*", "bndl", ")", "[", "j", "]", "\n", "tx", ".", "Persistence", "=", "&", "states", "[", "i", "]", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "bundles", ",", "err", "\n", "}" ]

[ "GetBundlesFromAddresses", "fetches", "all", "bundles", "from", "the", "given", "addresses", "and", "optionally", "sets", "the", "confirmed", "property", "on", "each", "transaction", "using", "GetLatestInclusion", ".", "This", "function", "does", "not", "validate", "the", "bundles", "." ]

[ "func", "(", "api", "*", "API", ")", "IsAddressUsed", "(", "address", "Hash", ")", "(", "bool", ",", "error", ")", "{", "var", "err1", ",", "err2", "error", "\n", "var", "states", "[", "]", "bool", "\n", "var", "txs", "Hashes", "\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "wg", ".", "Add", "(", "2", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "states", ",", "err1", "=", "api", ".", "WereAddressesSpentFrom", "(", "address", ")", "\n", "}", "(", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "txs", ",", "err2", "=", "api", ".", "FindTransactions", "(", "FindTransactionsQuery", "{", "Addresses", ":", "Hashes", "{", "address", "}", "}", ")", "\n", "}", "(", ")", "\n", "wg", ".", "Wait", "(", ")", "\n\n", "if", "err", ":=", "firstNonNilErr", "(", "err1", ",", "err2", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "states", "[", "0", "]", "||", "len", "(", "txs", ")", ">", "0", "{", "return", "true", ",", "nil", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "IsAddressUsed", "checks", "whether", "an", "address", "is", "used", "via", "FindTransactions", "and", "WereAddressesSpentFrom", "." ]

[ "func", "getUntilFirstUnusedAddress", "(", "isAddressUsed", "isAddressUsedFunc", ",", "seed", "Trytes", ",", "index", "uint64", ",", "security", "SecurityLevel", ",", "returnAll", "bool", ",", ")", "(", "Hashes", ",", "error", ")", "{", "addresses", ":=", "Hashes", "{", "}", "\n\n", "for", ";", ";", "index", "++", "{", "nextAddress", ",", "err", ":=", "address", ".", "GenerateAddress", "(", "seed", ",", "index", ",", "security", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "returnAll", "{", "addresses", "=", "append", "(", "addresses", ",", "nextAddress", ")", "\n", "}", "\n\n", "used", ",", "err", ":=", "isAddressUsed", "(", "nextAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "used", "{", "continue", "\n", "}", "\n\n", "if", "!", "returnAll", "{", "addresses", "=", "append", "(", "addresses", ",", "nextAddress", ")", "\n", "}", "\n\n", "return", "addresses", ",", "nil", "\n", "}", "\n", "}" ]

[ "computes", "after", "a", "best", "effort", "method", "the", "first", "unused", "addresses" ]

[ "func", "(", "api", "*", "API", ")", "GetTransactionObjects", "(", "hashes", "...", "Hash", ")", "(", "transaction", ".", "Transactions", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateTransactionHashes", "(", "hashes", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "trytes", ",", "err", ":=", "api", ".", "GetTrytes", "(", "hashes", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "transaction", ".", "AsTransactionObjects", "(", "trytes", ",", "hashes", ")", "\n", "}" ]

[ "GetTransactionObjects", "fetches", "transaction", "objects", "given", "an", "array", "of", "transaction", "hashes", "." ]

[ "func", "(", "api", "*", "API", ")", "FindTransactionObjects", "(", "query", "FindTransactionsQuery", ")", "(", "transaction", ".", "Transactions", ",", "error", ")", "{", "txHashes", ",", "err", ":=", "api", ".", "FindTransactions", "(", "query", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "txHashes", ")", "==", "0", "{", "return", "transaction", ".", "Transactions", "{", "}", ",", "nil", "\n", "}", "\n", "return", "api", ".", "GetTransactionObjects", "(", "txHashes", "...", ")", "\n", "}" ]

[ "FindTransactionObjects", "searches", "for", "transactions", "given", "a", "query", "object", "with", "addresses", "tags", "and", "approvees", "fields", ".", "Multiple", "query", "fields", "are", "supported", "and", "FindTransactionObjects", "returns", "the", "intersection", "of", "results", "." ]

[ "func", "(", "api", "*", "API", ")", "GetInputs", "(", "seed", "Trytes", ",", "options", "GetInputsOptions", ")", "(", "*", "Inputs", ",", "error", ")", "{", "options", "=", "getInputDefaultOptions", "(", "options", ")", "\n", "if", "err", ":=", "Validate", "(", "ValidateSeed", "(", "seed", ")", ",", "ValidateSecurityLevel", "(", "options", ".", "Security", ")", ",", "ValidateStartEndOptions", "(", "options", ".", "Start", ",", "options", ".", "End", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "opts", ":=", "options", ".", "ToGetNewAddressOptions", "(", ")", "\n", "addresses", ",", "err", ":=", "api", ".", "GetNewAddress", "(", "seed", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "balances", ",", "err", ":=", "api", ".", "GetBalances", "(", "addresses", ",", "100", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "inputs", ":=", "api", ".", "GetInputObjects", "(", "addresses", ",", "balances", ".", "Balances", ",", "opts", ".", "Index", ",", "opts", ".", "Security", ")", "\n\n", "// threshold is an api hard cap for needed inputs to fulfil the threshold value", "if", "options", ".", "Threshold", "!=", "nil", "{", "threshold", ":=", "*", "options", ".", "Threshold", "\n\n", "if", "threshold", ">", "inputs", ".", "TotalBalance", "{", "return", "nil", ",", "ErrInsufficientBalance", "\n", "}", "\n\n", "thresholdInputs", ":=", "Inputs", "{", "}", "\n", "for", "i", ":=", "range", "inputs", ".", "Inputs", "{", "if", "thresholdInputs", ".", "TotalBalance", ">=", "threshold", "{", "break", "\n", "}", "\n", "input", ":=", "inputs", ".", "Inputs", "[", "i", "]", "\n", "thresholdInputs", ".", "Inputs", "=", "append", "(", "thresholdInputs", ".", "Inputs", ",", "input", ")", "\n", "thresholdInputs", ".", "TotalBalance", "+=", "input", ".", "Balance", "\n", "}", "\n", "inputs", "=", "thresholdInputs", "\n", "}", "\n\n", "return", "&", "inputs", ",", "nil", "\n", "}" ]

[ "GetInputs", "creates", "and", "returns", "an", "Inputs", "object", "by", "generating", "addresses", "and", "fetching", "their", "latest", "balance", "." ]

[ "func", "(", "api", "*", "API", ")", "GetInputObjects", "(", "addresses", "Hashes", ",", "balances", "[", "]", "uint64", ",", "start", "uint64", ",", "secLvl", "SecurityLevel", ")", "Inputs", "{", "addrs", ":=", "[", "]", "Input", "{", "}", "\n", "var", "totalBalance", "uint64", "\n", "for", "i", ":=", "range", "addresses", "{", "value", ":=", "balances", "[", "i", "]", "\n", "if", "value", "<=", "0", "{", "continue", "\n", "}", "\n", "addrs", "=", "append", "(", "addrs", ",", "Input", "{", "Address", ":", "addresses", "[", "i", "]", ",", "Security", ":", "secLvl", ",", "Balance", ":", "value", ",", "KeyIndex", ":", "start", "+", "uint64", "(", "i", ")", "}", ",", ")", "\n", "totalBalance", "+=", "value", "\n", "}", "\n", "return", "Inputs", "{", "Inputs", ":", "addrs", ",", "TotalBalance", ":", "totalBalance", "}", "\n", "}" ]

[ "GetInputObjects", "creates", "an", "Input", "object", "using", "the", "given", "addresses", "balances", "start", "index", "and", "security", "level", "." ]

[ "func", "(", "api", "*", "API", ")", "GetTransfers", "(", "seed", "Trytes", ",", "options", "GetTransfersOptions", ")", "(", "bundle", ".", "Bundles", ",", "error", ")", "{", "options", "=", "getTransfersDefaultOptions", "(", "options", ")", "\n", "if", "err", ":=", "Validate", "(", "ValidateSeed", "(", "seed", ")", ",", "ValidateSecurityLevel", "(", "options", ".", "Security", ")", ",", "ValidateStartEndOptions", "(", "options", ".", "Start", ",", "options", ".", "End", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "addresses", ",", "err", ":=", "api", ".", "GetNewAddress", "(", "seed", ",", "options", ".", "ToGetNewAddressOptions", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "api", ".", "GetBundlesFromAddresses", "(", "addresses", ",", "options", ".", "InclusionStates", ")", "\n", "}" ]

[ "GetTransfers", "returns", "bundles", "which", "operated", "on", "the", "given", "address", "range", "specified", "by", "the", "supplied", "options", "." ]

[ "func", "(", "api", "*", "API", ")", "IsPromotable", "(", "tailTxHash", "Hash", ")", "(", "bool", ",", "error", ")", "{", "var", "err1", ",", "err2", "error", "\n", "var", "isConsistent", "bool", "\n", "var", "trytes", "[", "]", "Trytes", "\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "wg", ".", "Add", "(", "2", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "isConsistent", ",", "_", ",", "err1", "=", "api", ".", "CheckConsistency", "(", "tailTxHash", ")", "\n", "}", "(", ")", "\n\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "trytes", ",", "err2", "=", "api", ".", "GetTrytes", "(", "tailTxHash", ")", "\n", "}", "(", ")", "\n\n", "wg", ".", "Wait", "(", ")", "\n", "if", "err", ":=", "firstNonNilErr", "(", "err1", ",", "err2", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "tx", ",", "err", ":=", "transaction", ".", "AsTransactionObject", "(", "trytes", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "isConsistent", "&&", "isAboveMaxDepth", "(", "tx", ".", "AttachmentTimestamp", ")", ",", "nil", "\n", "}" ]

[ "IsPromotable", "checks", "if", "a", "transaction", "is", "promotable", "by", "calling", "the", "checkConsistency", "IRI", "API", "command", "and", "verifying", "that", "attachmentTimestamp", "is", "above", "a", "lower", "bound", ".", "Lower", "bound", "is", "calculated", "based", "on", "the", "number", "of", "milestones", "issued", "since", "transaction", "attachment", "." ]

[ "func", "isAboveMaxDepth", "(", "attachmentTimestamp", "int64", ")", "bool", "{", "nowMilli", ":=", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", "/", "int64", "(", "time", ".", "Millisecond", ")", "\n", "return", "attachmentTimestamp", "<", "nowMilli", "&&", "nowMilli", "-", "attachmentTimestamp", "<", "maxDepth", "*", "milestoneInterval", "*", "oneWayDelay", "\n", "}" ]

[ "checks", "whether", "by", "the", "given", "timestamp", "the", "transaction", "is", "to", "deep", "to", "be", "promoted" ]

[ "func", "(", "api", "*", "API", ")", "SendTransfer", "(", "seed", "Trytes", ",", "depth", "uint64", ",", "mwm", "uint64", ",", "transfers", "bundle", ".", "Transfers", ",", "options", "*", "SendTransfersOptions", ")", "(", "bundle", ".", "Bundle", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateSeed", "(", "seed", ")", ",", "ValidateTransfers", "(", "transfers", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "opts", "PrepareTransfersOptions", "\n", "refs", ":=", "Hashes", "{", "}", "\n", "if", "options", "==", "nil", "{", "opts", "=", "getPrepareTransfersDefaultOptions", "(", "PrepareTransfersOptions", "{", "}", ")", "\n", "}", "else", "{", "opts", "=", "getPrepareTransfersDefaultOptions", "(", "options", ".", "PrepareTransfersOptions", ")", "\n", "if", "options", ".", "Reference", "!=", "nil", "{", "refs", "=", "append", "(", "refs", ",", "*", "options", ".", "Reference", ")", "\n", "}", "\n", "}", "\n\n", "trytes", ",", "err", ":=", "api", ".", "PrepareTransfers", "(", "seed", ",", "transfers", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "api", ".", "SendTrytes", "(", "trytes", ",", "depth", ",", "mwm", ",", "refs", "...", ")", "\n", "}" ]

[ "SendTransfer", "calls", "PrepareTransfers", "and", "then", "sends", "off", "the", "bundle", "via", "SendTrytes", "." ]

[ "func", "(", "api", "*", "API", ")", "ReplayBundle", "(", "tailTxHash", "Hash", ",", "depth", "uint64", ",", "mwm", "uint64", ",", "reference", "...", "Hash", ")", "(", "bundle", ".", "Bundle", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateTransactionHashes", "(", "tailTxHash", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "bndl", ",", "err", ":=", "api", ".", "GetBundle", "(", "tailTxHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "trytes", ":=", "transaction", ".", "MustFinalTransactionTrytes", "(", "bndl", ")", "\n", "return", "api", ".", "SendTrytes", "(", "trytes", ",", "depth", ",", "mwm", ",", "reference", "...", ")", "\n", "}" ]

[ "ReplayBundle", "reattaches", "a", "transfer", "to", "the", "Tangle", "by", "selecting", "tips", "&", "performing", "the", "Proof", "-", "of", "-", "Work", "again", ".", "Reattachments", "are", "useful", "in", "case", "original", "transactions", "are", "pending", "and", "can", "be", "done", "securely", "as", "many", "times", "as", "needed", "." ]

[ "func", "(", "api", "*", "API", ")", "SendTrytes", "(", "trytes", "[", "]", "Trytes", ",", "depth", "uint64", ",", "mwm", "uint64", ",", "reference", "...", "Hash", ")", "(", "bundle", ".", "Bundle", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateTransactionTrytes", "(", "trytes", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tips", ",", "err", ":=", "api", ".", "GetTransactionsToApprove", "(", "depth", ",", "reference", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "trytes", ",", "err", "=", "api", ".", "AttachToTangle", "(", "tips", ".", "TrunkTransaction", ",", "tips", ".", "BranchTransaction", ",", "mwm", ",", "trytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "trytes", ",", "err", "=", "api", ".", "StoreAndBroadcast", "(", "trytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "transaction", ".", "AsTransactionObjects", "(", "trytes", ",", "nil", ")", "\n", "}" ]

[ "SendTrytes", "performs", "Proof", "-", "of", "-", "Work", "stores", "and", "then", "broadcasts", "the", "given", "transactions", "and", "returns", "them", "." ]

[ "func", "(", "api", "*", "API", ")", "StoreAndBroadcast", "(", "trytes", "[", "]", "Trytes", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateAttachedTransactionTrytes", "(", "trytes", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "trytes", ",", "err", ":=", "api", ".", "StoreTransactions", "(", "trytes", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "api", ".", "BroadcastTransactions", "(", "trytes", "...", ")", "\n", "}" ]

[ "StoreAndBroadcast", "first", "stores", "and", "the", "broadcasts", "the", "given", "transactions", "." ]

[ "func", "(", "api", "*", "API", ")", "TraverseBundle", "(", "trunkTxHash", "Hash", ",", "bndl", "bundle", ".", "Bundle", ")", "(", "bundle", ".", "Bundle", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateTransactionHashes", "(", "trunkTxHash", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tailTrytes", ",", "err", ":=", "api", ".", "GetTrytes", "(", "trunkTxHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tx", ",", "err", ":=", "transaction", ".", "AsTransactionObject", "(", "tailTrytes", "[", "0", "]", ",", "trunkTxHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// tail tx ?", "if", "len", "(", "bndl", ")", "==", "0", "{", "if", "!", "transaction", ".", "IsTailTransaction", "(", "tx", ")", "{", "return", "nil", ",", "ErrInvalidTailTransaction", "\n", "}", "\n", "}", "\n", "bndl", "=", "append", "(", "bndl", ",", "*", "tx", ")", "\n", "if", "tx", ".", "CurrentIndex", "==", "tx", ".", "LastIndex", "{", "return", "bndl", ",", "nil", "\n", "}", "\n", "return", "api", ".", "TraverseBundle", "(", "tx", ".", "TrunkTransaction", ",", "bndl", ")", "\n", "}" ]

[ "TraverseBundle", "fetches", "the", "bundle", "of", "a", "given", "tail", "transaction", "by", "traversing", "through", "the", "trunk", "transactions", ".", "It", "does", "not", "validate", "the", "bundle", "." ]

[ "func", "xorInGeneric", "(", "d", "*", "state", ",", "buf", "[", "]", "byte", ")", "{", "n", ":=", "len", "(", "buf", ")", "/", "8", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "n", ";", "i", "++", "{", "a", ":=", "binary", ".", "LittleEndian", ".", "Uint64", "(", "buf", ")", "\n", "d", ".", "a", "[", "i", "]", "^=", "a", "\n", "buf", "=", "buf", "[", "8", ":", "]", "\n", "}", "\n", "}" ]

[ "xorInGeneric", "xors", "the", "bytes", "in", "buf", "into", "the", "state", ";", "it", "makes", "no", "non", "-", "portable", "assumptions", "about", "memory", "layout", "or", "alignment", "." ]

[ "func", "copyOutGeneric", "(", "d", "*", "state", ",", "b", "[", "]", "byte", ")", "{", "for", "i", ":=", "0", ";", "len", "(", "b", ")", ">=", "8", ";", "i", "++", "{", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "b", ",", "d", ".", "a", "[", "i", "]", ")", "\n", "b", "=", "b", "[", "8", ":", "]", "\n", "}", "\n", "}" ]

[ "copyOutGeneric", "copies", "ulint64s", "to", "a", "byte", "buffer", "." ]

[ "func", "(", "d", "*", "state", ")", "Reset", "(", ")", "{", "// Zero the permutation's state.", "for", "i", ":=", "range", "d", ".", "a", "{", "d", ".", "a", "[", "i", "]", "=", "0", "\n", "}", "\n", "d", ".", "state", "=", "spongeAbsorbing", "\n", "d", ".", "buf", "=", "d", ".", "storage", "[", ":", "0", "]", "\n", "}" ]

[ "Reset", "clears", "the", "internal", "state", "by", "zeroing", "the", "sponge", "state", "and", "the", "byte", "buffer", "and", "setting", "Sponge", ".", "state", "to", "absorbing", "." ]

[ "func", "(", "d", "*", "state", ")", "permute", "(", ")", "{", "switch", "d", ".", "state", "{", "case", "spongeAbsorbing", ":", "// If we're absorbing, we need to xor the input into the state", "// before applying the permutation.", "xorIn", "(", "d", ",", "d", ".", "buf", ")", "\n", "d", ".", "buf", "=", "d", ".", "storage", "[", ":", "0", "]", "\n", "keccakF1600", "(", "&", "d", ".", "a", ")", "\n", "case", "spongeSqueezing", ":", "// If we're squeezing, we need to apply the permutatin before", "// copying more output.", "keccakF1600", "(", "&", "d", ".", "a", ")", "\n", "d", ".", "buf", "=", "d", ".", "storage", "[", ":", "d", ".", "rate", "]", "\n", "copyOut", "(", "d", ",", "d", ".", "buf", ")", "\n", "}", "\n", "}" ]

[ "permute", "applies", "the", "KeccakF", "-", "1600", "permutation", ".", "It", "handles", "any", "input", "-", "output", "buffering", "." ]

[ "func", "(", "d", "*", "state", ")", "padAndPermute", "(", "dsbyte", "byte", ")", "{", "if", "d", ".", "buf", "==", "nil", "{", "d", ".", "buf", "=", "d", ".", "storage", "[", ":", "0", "]", "\n", "}", "\n", "// Pad with this instance's domain-separator bits. We know that there's", "// at least one byte of space in d.buf because, if it were full,", "// permute would have been called to empty it. dsbyte also contains the", "// first one bit for the padding. See the comment in the state struct.", "d", ".", "buf", "=", "append", "(", "d", ".", "buf", ",", "dsbyte", ")", "\n", "zerosStart", ":=", "len", "(", "d", ".", "buf", ")", "\n", "d", ".", "buf", "=", "d", ".", "storage", "[", ":", "d", ".", "rate", "]", "\n", "for", "i", ":=", "zerosStart", ";", "i", "<", "d", ".", "rate", ";", "i", "++", "{", "d", ".", "buf", "[", "i", "]", "=", "0", "\n", "}", "\n", "// This adds the final one bit for the padding. Because of the way that", "// bits are numbered from the LSB upwards, the final bit is the MSB of", "// the last byte.", "d", ".", "buf", "[", "d", ".", "rate", "-", "1", "]", "^=", "0x80", "\n", "// Apply the permutation", "d", ".", "permute", "(", ")", "\n", "d", ".", "state", "=", "spongeSqueezing", "\n", "d", ".", "buf", "=", "d", ".", "storage", "[", ":", "d", ".", "rate", "]", "\n", "copyOut", "(", "d", ",", "d", ".", "buf", ")", "\n", "}" ]

[ "pads", "appends", "the", "domain", "separation", "bits", "in", "dsbyte", "applies", "the", "multi", "-", "bitrate", "10", "..", "1", "padding", "rule", "and", "permutes", "the", "state", "." ]

[ "func", "(", "d", "*", "state", ")", "Write", "(", "p", "[", "]", "byte", ")", "(", "written", "int", ",", "err", "error", ")", "{", "if", "d", ".", "state", "!=", "spongeAbsorbing", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "d", ".", "buf", "==", "nil", "{", "d", ".", "buf", "=", "d", ".", "storage", "[", ":", "0", "]", "\n", "}", "\n", "written", "=", "len", "(", "p", ")", "\n\n", "for", "len", "(", "p", ")", ">", "0", "{", "if", "len", "(", "d", ".", "buf", ")", "==", "0", "&&", "len", "(", "p", ")", ">=", "d", ".", "rate", "{", "// The fast path; absorb a full \"rate\" bytes of input and apply the permutation.", "xorIn", "(", "d", ",", "p", "[", ":", "d", ".", "rate", "]", ")", "\n", "p", "=", "p", "[", "d", ".", "rate", ":", "]", "\n", "keccakF1600", "(", "&", "d", ".", "a", ")", "\n", "}", "else", "{", "// The slow path; buffer the input until we can fill the sponge, and then xor it in.", "todo", ":=", "d", ".", "rate", "-", "len", "(", "d", ".", "buf", ")", "\n", "if", "todo", ">", "len", "(", "p", ")", "{", "todo", "=", "len", "(", "p", ")", "\n", "}", "\n", "d", ".", "buf", "=", "append", "(", "d", ".", "buf", ",", "p", "[", ":", "todo", "]", "...", ")", "\n", "p", "=", "p", "[", "todo", ":", "]", "\n\n", "// If the sponge is full, apply the permutation.", "if", "len", "(", "d", ".", "buf", ")", "==", "d", ".", "rate", "{", "d", ".", "permute", "(", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Write", "absorbs", "more", "data", "into", "the", "hash", "s", "state", ".", "It", "produces", "an", "error", "if", "more", "data", "is", "written", "to", "the", "ShakeHash", "after", "writing" ]

[ "func", "(", "d", "*", "state", ")", "Sum", "(", "in", "[", "]", "byte", ")", "[", "]", "byte", "{", "// Make a copy of the original hash so that caller can keep writing", "// and summing.", "dup", ":=", "d", ".", "clone", "(", ")", "\n", "hash", ":=", "make", "(", "[", "]", "byte", ",", "dup", ".", "outputLen", ")", "\n", "dup", ".", "Read", "(", "hash", ")", "\n", "return", "append", "(", "in", ",", "hash", "...", ")", "\n", "}" ]

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

[ "func", "NewShake128", "(", ")", "ShakeHash", "{", "if", "h", ":=", "newShake128Asm", "(", ")", ";", "h", "!=", "nil", "{", "return", "h", "\n", "}", "\n", "return", "&", "state", "{", "rate", ":", "168", ",", "dsbyte", ":", "0x1f", "}", "\n", "}" ]

[ "NewShake128", "creates", "a", "new", "SHAKE128", "variable", "-", "output", "-", "length", "ShakeHash", ".", "Its", "generic", "security", "strength", "is", "128", "bits", "against", "all", "attacks", "if", "at", "least", "32", "bytes", "of", "its", "output", "are", "used", "." ]

[ "func", "NewShake256", "(", ")", "ShakeHash", "{", "if", "h", ":=", "newShake256Asm", "(", ")", ";", "h", "!=", "nil", "{", "return", "h", "\n", "}", "\n", "return", "&", "state", "{", "rate", ":", "136", ",", "dsbyte", ":", "0x1f", "}", "\n", "}" ]

[ "NewShake256", "creates", "a", "new", "SHAKE256", "variable", "-", "output", "-", "length", "ShakeHash", ".", "Its", "generic", "security", "strength", "is", "256", "bits", "against", "all", "attacks", "if", "at", "least", "64", "bytes", "of", "its", "output", "are", "used", "." ]

[ "func", "ShakeSum128", "(", "hash", ",", "data", "[", "]", "byte", ")", "{", "h", ":=", "NewShake128", "(", ")", "\n", "h", ".", "Write", "(", "data", ")", "\n", "h", ".", "Read", "(", "hash", ")", "\n", "}" ]

[ "ShakeSum128", "writes", "an", "arbitrary", "-", "length", "digest", "of", "data", "into", "hash", "." ]

[ "func", "ShakeSum256", "(", "hash", ",", "data", "[", "]", "byte", ")", "{", "h", ":=", "NewShake256", "(", ")", "\n", "h", ".", "Write", "(", "data", ")", "\n", "h", ".", "Read", "(", "hash", ")", "\n", "}" ]

[ "ShakeSum256", "writes", "an", "arbitrary", "-", "length", "digest", "of", "data", "into", "hash", "." ]

[ "func", "GetSpongeFunc", "(", "spongeFunc", "[", "]", "SpongeFunction", ",", "defaultSpongeFuncCreator", "...", "SpongeFunctionCreator", ")", "SpongeFunction", "{", "if", "len", "(", "spongeFunc", ")", ">", "0", "{", "return", "spongeFunc", "[", "0", "]", "\n", "}", "\n", "if", "len", "(", "defaultSpongeFuncCreator", ")", ">", "0", "{", "return", "defaultSpongeFuncCreator", "[", "0", "]", "(", ")", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "GetSpongeFunc", "checks", "if", "a", "hash", "function", "was", "given", "otherwise", "uses", "defaultSpongeFuncCreator", ".", "Panics", "if", "none", "given", "." ]

[ "func", "AddChecksum", "(", "input", "Trytes", ",", "isAddress", "bool", ",", "checksumLength", "uint64", ")", "(", "Trytes", ",", "error", ")", "{", "if", "isAddress", "&&", "len", "(", "input", ")", "!=", "HashTrytesSize", "{", "if", "len", "(", "input", ")", "==", "AddressWithChecksumTrytesSize", "{", "return", "input", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "ErrInvalidAddress", "\n", "}", "\n\n", "if", "checksumLength", "<", "MinChecksumTrytesSize", "||", "(", "isAddress", "&&", "checksumLength", "!=", "AddressChecksumTrytesSize", ")", "{", "return", "\"", "\"", ",", "ErrInvalidChecksum", "\n", "}", "\n\n", "inputCopy", ":=", "input", "\n\n", "for", "len", "(", "inputCopy", ")", "%", "HashTrytesSize", "!=", "0", "{", "inputCopy", "+=", "\"", "\"", "\n", "}", "\n\n", "inputTrits", ":=", "MustTrytesToTrits", "(", "inputCopy", ")", "\n", "k", ":=", "kerl", ".", "NewKerl", "(", ")", "\n", "if", "err", ":=", "k", ".", "Absorb", "(", "inputTrits", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "checksumTrits", ",", "err", ":=", "k", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "input", "+=", "MustTritsToTrytes", "(", "checksumTrits", "[", "HashTrinarySize", "-", "checksumLength", "*", "3", ":", "HashTrinarySize", "]", ")", "\n", "return", "input", ",", "nil", "\n", "}" ]

[ "AddChecksum", "computes", "the", "checksum", "and", "returns", "the", "given", "trytes", "with", "the", "appended", "checksum", ".", "If", "isAddress", "is", "true", "then", "the", "input", "trytes", "must", "be", "of", "length", "HashTrytesSize", ".", "Specified", "checksum", "length", "must", "be", "at", "least", "MinChecksumTrytesSize", "long", "or", "it", "must", "be", "AddressChecksumTrytesSize", "if", "isAddress", "is", "true", "." ]

[ "func", "AddChecksums", "(", "inputs", "[", "]", "Trytes", ",", "isAddress", "bool", ",", "checksumLength", "uint64", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "withChecksums", ":=", "make", "(", "[", "]", "Trytes", ",", "len", "(", "inputs", ")", ")", "\n", "for", "i", ",", "s", ":=", "range", "inputs", "{", "t", ",", "err", ":=", "AddChecksum", "(", "s", ",", "isAddress", ",", "checksumLength", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "withChecksums", "[", "i", "]", "=", "t", "\n", "}", "\n", "return", "withChecksums", ",", "nil", "\n", "}" ]

[ "AddChecksums", "is", "a", "wrapper", "function", "around", "AddChecksum", "for", "multiple", "trytes", "strings", "." ]

[ "func", "RemoveChecksum", "(", "input", "Trytes", ")", "(", "Trytes", ",", "error", ")", "{", "if", "!", "guards", ".", "IsTrytesOfExactLength", "(", "input", ",", "HashTrytesSize", ")", "&&", "!", "guards", ".", "IsTrytesOfExactLength", "(", "input", ",", "AddressWithChecksumTrytesSize", ")", "{", "return", "\"", "\"", ",", "ErrInvalidAddress", "\n", "}", "\n", "return", "input", "[", ":", "HashTrytesSize", "]", ",", "nil", "\n", "}" ]

[ "RemoveChecksum", "removes", "the", "checksum", "from", "the", "given", "trytes", ".", "The", "input", "trytes", "must", "be", "of", "length", "HashTrytesSize", "or", "AddressWithChecksumTrytesSize", "." ]

[ "func", "RemoveChecksums", "(", "inputs", "[", "]", "Trytes", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "withoutChecksums", ":=", "make", "(", "[", "]", "Trytes", ",", "len", "(", "inputs", ")", ")", "\n", "for", "i", ",", "s", ":=", "range", "inputs", "{", "t", ",", "err", ":=", "RemoveChecksum", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "withoutChecksums", "[", "i", "]", "=", "t", "\n", "}", "\n", "return", "withoutChecksums", ",", "nil", "\n", "}" ]

[ "RemoveChecksums", "is", "a", "wrapper", "function", "around", "RemoveChecksum", "for", "multiple", "trytes", "strings", "." ]

[ "func", "ConvertUnits", "(", "val", "float64", ",", "from", "Unit", ",", "to", "Unit", ")", "float64", "{", "value", ":=", "Unit", "(", "val", ")", "\n", "// convert to I unit by multiplying with the current unit", "value", "*=", "from", "\n", "// convert to the target unit by dividing by it", "if", "to", "==", "I", "{", "return", "math", ".", "Round", "(", "float64", "(", "value", ")", ")", "\n", "}", "\n", "value", "/=", "to", "\n", "return", "float64", "(", "value", ")", "\n", "}" ]

[ "ConvertUnits", "converts", "the", "given", "value", "in", "the", "base", "Unit", "to", "the", "given", "new", "Unit", "." ]

[ "func", "ConvertUnitsString", "(", "val", "string", ",", "from", "Unit", ",", "to", "Unit", ")", "(", "float64", ",", "error", ")", "{", "floatValue", ",", "err", ":=", "strconv", ".", "ParseFloat", "(", "val", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "ConvertUnits", "(", "floatValue", ",", "from", ",", "to", ")", ",", "nil", "\n", "}" ]

[ "ConvertUnitsString", "converts", "the", "given", "string", "value", "in", "the", "base", "Unit", "to", "the", "given", "new", "Unit", "." ]

[ "func", "(", "recipients", "Recipients", ")", "Sum", "(", ")", "uint64", "{", "var", "sum", "uint64", "\n", "for", "_", ",", "target", ":=", "range", "recipients", "{", "sum", "+=", "target", ".", "Value", "\n", "}", "\n", "return", "sum", "\n", "}" ]

[ "Sum", "returns", "the", "sum", "of", "all", "amounts", "." ]

[ "func", "(", "recipients", "Recipients", ")", "AsTransfers", "(", ")", "bundle", ".", "Transfers", "{", "transfers", ":=", "make", "(", "bundle", ".", "Transfers", ",", "len", "(", "recipients", ")", ")", "\n", "for", "i", ",", "recipient", ":=", "range", "recipients", "{", "transfers", "[", "i", "]", "=", "recipient", "\n", "}", "\n", "return", "transfers", "\n", "}" ]

[ "AsTransfers", "converts", "the", "recipients", "to", "transfers", "." ]

[ "func", "DefaultAddrGen", "(", "provider", "SeedProvider", ",", "withCache", "bool", ")", "AddrGenFunc", "{", "var", "cacheMu", "sync", ".", "Mutex", "\n", "var", "cache", "map", "[", "uint64", "]", "map", "[", "consts", ".", "SecurityLevel", "]", "trinary", ".", "Hash", "\n\n", "if", "withCache", "{", "cache", "=", "map", "[", "uint64", "]", "map", "[", "consts", ".", "SecurityLevel", "]", "trinary", ".", "Hash", "{", "}", "\n", "}", "\n\n", "read", ":=", "func", "(", "index", "uint64", ",", "secLvl", "consts", ".", "SecurityLevel", ",", "addChecksum", "bool", ")", "trinary", ".", "Hash", "{", "cacheMu", ".", "Lock", "(", ")", "\n", "defer", "cacheMu", ".", "Unlock", "(", ")", "\n", "m", ",", "hasEntry", ":=", "cache", "[", "index", "]", "\n", "if", "!", "hasEntry", "{", "return", "\"", "\"", "\n", "}", "\n", "cachedAddr", ",", "hasAddr", ":=", "m", "[", "secLvl", "]", "\n", "if", "!", "hasAddr", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "addChecksum", "{", "return", "cachedAddr", "\n", "}", "\n", "return", "cachedAddr", "[", ":", "consts", ".", "HashTrytesSize", "]", "\n", "}", "\n\n", "write", ":=", "func", "(", "index", "uint64", ",", "secLvl", "consts", ".", "SecurityLevel", ",", "addr", "trinary", ".", "Hash", ")", "{", "cacheMu", ".", "Lock", "(", ")", "\n", "defer", "cacheMu", ".", "Unlock", "(", ")", "\n", "m", ",", "hasEntry", ":=", "cache", "[", "index", "]", "\n", "if", "!", "hasEntry", "{", "m", "=", "map", "[", "consts", ".", "SecurityLevel", "]", "trinary", ".", "Hash", "{", "}", "\n", "m", "[", "secLvl", "]", "=", "addr", "\n", "cache", "[", "index", "]", "=", "m", "\n", "return", "\n", "}", "\n", "m", "[", "secLvl", "]", "=", "addr", "\n", "}", "\n\n", "generate", ":=", "func", "(", "index", "uint64", ",", "secLvl", "consts", ".", "SecurityLevel", ")", "(", "trinary", ".", "Hash", ",", "error", ")", "{", "seed", ",", "err", ":=", "provider", ".", "Seed", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "addr", ",", "err", ":=", "address", ".", "GenerateAddress", "(", "seed", ",", "index", ",", "secLvl", ",", "true", ")", "\n", "return", "addr", ",", "err", "\n", "}", "\n\n", "if", "!", "withCache", "{", "return", "func", "(", "index", "uint64", ",", "secLvl", "consts", ".", "SecurityLevel", ",", "addChecksum", "bool", ")", "(", "trinary", ".", "Hash", ",", "error", ")", "{", "addr", ",", "err", ":=", "generate", "(", "index", ",", "secLvl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "addChecksum", "{", "return", "addr", ",", "nil", "\n", "}", "\n", "return", "addr", "[", ":", "consts", ".", "HashTrytesSize", "]", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "func", "(", "index", "uint64", ",", "secLvl", "consts", ".", "SecurityLevel", ",", "addChecksum", "bool", ")", "(", "trinary", ".", "Hash", ",", "error", ")", "{", "if", "hash", ":=", "read", "(", "index", ",", "secLvl", ",", "addChecksum", ")", ";", "hash", "!=", "\"", "\"", "{", "return", "hash", ",", "nil", "\n", "}", "\n\n", "addr", ",", "err", ":=", "generate", "(", "index", ",", "secLvl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "write", "(", "index", ",", "secLvl", ",", "addr", ")", "\n", "if", "addChecksum", "{", "return", "addr", ",", "nil", "\n", "}", "\n", "return", "addr", "[", ":", "consts", ".", "HashTrytesSize", "]", ",", "nil", "\n", "}", "\n", "}" ]

[ "DefaultAddrGen", "is", "the", "default", "address", "generation", "function", "used", "by", "the", "account", "if", "non", "is", "specified", ".", "withCache", "creates", "a", "function", "which", "caches", "the", "computed", "addresses", "by", "the", "index", "and", "security", "level", "for", "subsequent", "calls", "." ]

[ "func", "DefaultPrepareTransfers", "(", "a", "*", "api", ".", "API", ",", "provider", "SeedProvider", ")", "PrepareTransfersFunc", "{", "return", "func", "(", "transfers", "bundle", ".", "Transfers", ",", "options", "api", ".", "PrepareTransfersOptions", ")", "(", "[", "]", "trinary", ".", "Trytes", ",", "error", ")", "{", "seed", ",", "err", ":=", "provider", ".", "Seed", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "a", ".", "PrepareTransfers", "(", "seed", ",", "transfers", ",", "options", ")", "\n", "}", "\n", "}" ]

[ "DefaultPrepareTransfers", "is", "the", "default", "prepare", "transfers", "function", "used", "by", "the", "account", "if", "non", "is", "specified", "." ]

[ "func", "(", "gio", "GetInputsOptions", ")", "ToGetNewAddressOptions", "(", ")", "GetNewAddressOptions", "{", "if", "gio", ".", "End", "!=", "nil", "{", "total", ":=", "*", "gio", ".", "End", "-", "gio", ".", "Start", "\n", "return", "GetNewAddressOptions", "{", "Index", ":", "gio", ".", "Start", ",", "Total", ":", "&", "total", ",", "Security", ":", "gio", ".", "Security", ",", "ReturnAll", ":", "true", ",", "}", "\n", "}", "\n", "return", "GetNewAddressOptions", "{", "Index", ":", "gio", ".", "Start", ",", "Security", ":", "gio", ".", "Security", ",", "ReturnAll", ":", "true", ",", "}", "\n", "}" ]

[ "ToGetNewAddressOptions", "converts", "GetInputsOptions", "to", "GetNewAddressOptions", "." ]

[ "func", "(", "gto", "GetTransfersOptions", ")", "ToGetNewAddressOptions", "(", ")", "GetNewAddressOptions", "{", "opts", ":=", "GetNewAddressOptions", "{", "}", "\n", "opts", ".", "Index", "=", "gto", ".", "Start", "\n", "opts", ".", "Security", "=", "gto", ".", "Security", "\n", "opts", ".", "ReturnAll", "=", "true", "\n", "if", "gto", ".", "End", "!=", "nil", "{", "total", ":=", "*", "gto", ".", "End", "-", "gto", ".", "Start", "\n", "opts", ".", "Total", "=", "&", "total", "\n", "}", "\n", "return", "opts", "\n", "}" ]

[ "ToGetNewAddressOptions", "converts", "GetTransfersOptions", "to", "GetNewAddressOptions", "." ]

[ "func", "(", "api", "*", "API", ")", "AddNeighbors", "(", "uris", "...", "string", ")", "(", "int64", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateURIs", "(", "uris", "...", ")", ",", "ValidateNonEmptyStrings", "(", "ErrInvalidURI", ",", "uris", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "cmd", ":=", "&", "AddNeighborsCommand", "{", "Command", ":", "Command", "{", "AddNeighborsCmd", "}", ",", "URIs", ":", "uris", "}", "\n", "rsp", ":=", "&", "AddNeighborsResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "rsp", ".", "AddedNeighbors", ",", "nil", "\n", "}" ]

[ "AddNeighbors", "adds", "a", "list", "of", "neighbors", "to", "the", "connected", "IRI", "node", ".", "Assumes", "addNeighbors", "command", "is", "available", "on", "the", "node", ".", "AddNeighbors", "has", "only", "a", "temporary", "effect", "until", "the", "node", "relaunches", "." ]

[ "func", "(", "api", "*", "API", ")", "BroadcastTransactions", "(", "trytes", "...", "Trytes", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateAttachedTransactionTrytes", "(", "trytes", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cmd", ":=", "&", "BroadcastTransactionsCommand", "{", "Trytes", ":", "trytes", ",", "Command", ":", "Command", "{", "BroadcastTransactionsCmd", "}", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "trytes", ",", "nil", "\n", "}" ]

[ "BroadcastTransactions", "broadcasts", "a", "list", "of", "attached", "transaction", "trytes", "to", "the", "network", ".", "Tip", "-", "selection", "and", "Proof", "-", "of", "-", "Work", "must", "be", "done", "first", "by", "calling", "GetTransactionsToApprove", "and", "AttachToTangle", "or", "an", "equivalent", "attach", "method", ".", "You", "may", "use", "this", "method", "to", "increase", "odds", "of", "effective", "transaction", "propagation", ".", "Persist", "the", "transaction", "trytes", "in", "local", "storage", "before", "calling", "this", "command", "for", "first", "time", "to", "ensure", "that", "reattachment", "is", "possible", "until", "your", "bundle", "has", "been", "included", "." ]

[ "func", "(", "api", "*", "API", ")", "GetBalances", "(", "addresses", "Hashes", ",", "threshold", "uint64", ",", "tips", "...", "Hash", ")", "(", "*", "Balances", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateAddresses", "(", "false", ",", "addresses", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "threshold", ">", "100", "{", "return", "nil", ",", "ErrInvalidThreshold", "\n", "}", "\n\n", "cleanedAddrs", ",", "err", ":=", "checksum", ".", "RemoveChecksums", "(", "addresses", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "cmd", ":=", "&", "GetBalancesCommand", "{", "Addresses", ":", "cleanedAddrs", ",", "Threshold", ":", "threshold", ",", "Command", ":", "Command", "{", "GetBalancesCmd", "}", ",", "Tips", ":", "tips", ",", "}", "\n", "rsp", ":=", "&", "GetBalancesResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "balances", ":=", "&", "Balances", "{", "Balances", ":", "make", "(", "[", "]", "uint64", ",", "len", "(", "rsp", ".", "Balances", ")", ")", ",", "Milestone", ":", "rsp", ".", "Milestone", ",", "MilestoneIndex", ":", "rsp", ".", "MilestoneIndex", ",", "}", "\n", "for", "i", ",", "s", ":=", "range", "rsp", ".", "Balances", "{", "num", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "s", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "balances", ".", "Balances", "[", "i", "]", "=", "num", "\n", "}", "\n", "return", "balances", ",", "err", "\n", "}" ]

[ "GetBalances", "fetches", "confirmed", "balances", "of", "the", "given", "addresses", "at", "the", "latest", "solid", "milestone", "." ]

[ "func", "(", "api", "*", "API", ")", "GetInclusionStates", "(", "txHashes", "Hashes", ",", "tips", "...", "Hash", ")", "(", "[", "]", "bool", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateTransactionHashes", "(", "txHashes", "...", ")", ",", "ValidateNonEmptyStrings", "(", "ErrInvalidTransactionHash", ",", "txHashes", "...", ")", ",", "ValidateTransactionHashes", "(", "tips", "...", ")", ",", "ValidateNonEmptyStrings", "(", "ErrInvalidTransactionHash", ",", "tips", "...", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "cmd", ":=", "&", "GetInclusionStatesCommand", "{", "Transactions", ":", "txHashes", ",", "Tips", ":", "tips", ",", "Command", ":", "Command", "{", "GetInclusionStatesCmd", "}", "}", "\n", "rsp", ":=", "&", "GetInclusionStatesResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "rsp", ".", "States", ",", "nil", "\n", "}" ]

[ "GetInclusionStates", "fetches", "inclusion", "states", "of", "a", "given", "list", "of", "transactions", "." ]

[ "func", "(", "api", "*", "API", ")", "GetNeighbors", "(", ")", "(", "Neighbors", ",", "error", ")", "{", "cmd", ":=", "&", "GetNeighborsCommand", "{", "Command", ":", "Command", "{", "GetNeighborsCmd", "}", "}", "\n", "rsp", ":=", "&", "GetNeighborsResponse", "{", "}", "\n", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "rsp", ".", "Neighbors", ",", "nil", "\n", "}" ]

[ "GetNeighbors", "returns", "the", "list", "of", "connected", "neighbors", "of", "the", "connected", "node", "." ]

[ "func", "(", "api", "*", "API", ")", "GetNodeInfo", "(", ")", "(", "*", "GetNodeInfoResponse", ",", "error", ")", "{", "cmd", ":=", "&", "GetNodeInfoCommand", "{", "Command", ":", "Command", "{", "GetNodeInfoCmd", "}", "}", "\n", "rsp", ":=", "&", "GetNodeInfoResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "rsp", ",", "nil", "\n", "}" ]

[ "GetNodeInfo", "returns", "information", "about", "the", "connected", "node", "." ]

[ "func", "(", "api", "*", "API", ")", "GetTrytes", "(", "hashes", "...", "Hash", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateNonEmptyStrings", "(", "ErrInvalidTransactionHash", ",", "hashes", "...", ")", ",", "ValidateTransactionHashes", "(", "hashes", "...", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cmd", ":=", "&", "GetTrytesCommand", "{", "Hashes", ":", "hashes", ",", "Command", ":", "Command", "{", "GetTrytesCmd", "}", "}", "\n", "rsp", ":=", "&", "GetTrytesResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "rsp", ".", "Trytes", ",", "nil", "\n", "}" ]

[ "GetTrytes", "fetches", "the", "transaction", "trytes", "given", "a", "list", "of", "transaction", "hashes", "." ]

[ "func", "(", "api", "*", "API", ")", "InterruptAttachToTangle", "(", ")", "error", "{", "cmd", ":=", "&", "InterruptAttachToTangleCommand", "{", "Command", ":", "Command", "{", "InterruptAttachToTangleCmd", "}", "}", "\n", "return", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "nil", ")", "\n", "}" ]

[ "InterruptAttachToTangle", "interrupts", "the", "currently", "ongoing", "Proof", "-", "of", "-", "Work", "on", "the", "connected", "node", "." ]

[ "func", "(", "api", "*", "API", ")", "RemoveNeighbors", "(", "uris", "...", "string", ")", "(", "int64", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateNonEmptyStrings", "(", "ErrInvalidURI", ",", "uris", "...", ")", ",", "ValidateURIs", "(", "uris", "...", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "cmd", ":=", "&", "RemoveNeighborsCommand", "{", "Command", ":", "Command", "{", "RemoveNeighborsCmd", "}", ",", "URIs", ":", "uris", "}", "\n", "rsp", ":=", "&", "RemoveNeighborsResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "rsp", ".", "RemovedNeighbors", ",", "nil", "\n", "}" ]

[ "RemoveNeighbors", "removes", "a", "list", "of", "neighbors", "from", "the", "connected", "IRI", "node", ".", "This", "method", "has", "a", "temporary", "effect", "until", "the", "IRI", "node", "relaunches", "." ]

[ "func", "(", "api", "*", "API", ")", "StoreTransactions", "(", "trytes", "...", "Trytes", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateNonEmptyStrings", "(", "ErrInvalidTrytes", ",", "trytes", "...", ")", ",", "ValidateAttachedTransactionTrytes", "(", "trytes", "...", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cmd", ":=", "&", "StoreTransactionsCommand", "{", "Trytes", ":", "trytes", ",", "Command", ":", "Command", "{", "StoreTransactionsCmd", "}", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "trytes", ",", "nil", "\n", "}" ]

[ "StoreTransactions", "persists", "a", "list", "of", "attached", "transaction", "trytes", "in", "the", "store", "of", "the", "connected", "node", ".", "Tip", "-", "selection", "and", "Proof", "-", "of", "-", "Work", "must", "be", "done", "first", "by", "calling", "GetTransactionsToApprove", "and", "AttachToTangle", "or", "an", "equivalent", "attach", "method", ".", "Persist", "the", "transaction", "trytes", "in", "local", "storage", "before", "calling", "this", "command", "to", "ensure", "reattachment", "is", "possible", "until", "your", "bundle", "has", "been", "included", ".", "Any", "transactions", "stored", "with", "this", "command", "will", "eventually", "be", "erased", "as", "a", "result", "of", "a", "snapshot", "." ]

[ "func", "(", "api", "*", "API", ")", "WereAddressesSpentFrom", "(", "addresses", "...", "Hash", ")", "(", "[", "]", "bool", ",", "error", ")", "{", "if", "err", ":=", "Validate", "(", "ValidateAddresses", "(", "false", ",", "addresses", "...", ")", ",", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "cleanedAddrs", ",", "err", ":=", "checksum", ".", "RemoveChecksums", "(", "addresses", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "cmd", ":=", "&", "WereAddressesSpentFromCommand", "{", "Addresses", ":", "cleanedAddrs", ",", "Command", ":", "Command", "{", "WereAddressesSpentFromCmd", "}", "}", "\n", "rsp", ":=", "&", "WereAddressesSpentFromResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "provider", ".", "Send", "(", "cmd", ",", "rsp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "rsp", ".", "States", ",", "nil", "\n", "}" ]

[ "WereAddressesSpentFrom", "checks", "whether", "the", "given", "addresses", "were", "already", "spent", "." ]

[ "func", "Hamming", "(", "c", "*", "curl", ".", "Curl", ",", "offset", ",", "end", ",", "security", "int", ")", "Trits", "{", "lmid", ",", "hmid", ":=", "pow", ".", "Para", "(", "c", ".", "State", ")", "\n\n", "lmid", "[", "offset", "]", "=", "pow", ".", "PearlDiverMidStateLow0", "\n", "hmid", "[", "offset", "]", "=", "pow", ".", "PearlDiverMidStateHigh0", "\n", "lmid", "[", "offset", "+", "1", "]", "=", "pow", ".", "PearlDiverMidStateLow1", "\n", "hmid", "[", "offset", "+", "1", "]", "=", "pow", ".", "PearlDiverMidStateHigh1", "\n", "lmid", "[", "offset", "+", "2", "]", "=", "pow", ".", "PearlDiverMidStateLow2", "\n", "hmid", "[", "offset", "+", "2", "]", "=", "pow", ".", "PearlDiverMidStateHigh2", "\n", "lmid", "[", "offset", "+", "3", "]", "=", "pow", ".", "PearlDiverMidStateLow3", "\n", "hmid", "[", "offset", "+", "3", "]", "=", "pow", ".", "PearlDiverMidStateHigh3", "\n\n", "cancelled", ":=", "false", "\n", "nonce", ",", "_", ",", "foundIndex", ":=", "pow", ".", "Loop", "(", "lmid", ",", "hmid", ",", "security", ",", "&", "cancelled", ",", "check", ",", "int", "(", "c", ".", "Rounds", ")", ")", "\n", "if", "foundIndex", ">=", "0", "{", "copy", "(", "c", ".", "State", "[", "offset", ":", "]", ",", "ptritsToTrits", "(", "lmid", ",", "hmid", ",", "uint64", "(", "foundIndex", ")", ",", "len", "(", "c", ".", "State", ")", "-", "offset", ")", ")", "\n", "return", "nonce", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Hamming", "calculates", "the", "hamming", "nonce", "." ]

[ "func", "ASCIIToTrytes", "(", "s", "string", ")", "(", "Trytes", ",", "error", ")", "{", "if", "!", "asciiRegex", ".", "MatchString", "(", "s", ")", "{", "return", "\"", "\"", ",", "ErrInvalidASCIIInput", "\n", "}", "\n\n", "trytesStr", ":=", "\"", "\"", "\n\n", "for", "_", ",", "c", ":=", "range", "s", "{", "trytesStr", "+=", "string", "(", "TryteAlphabet", "[", "c", "%", "27", "]", ")", "\n", "trytesStr", "+=", "string", "(", "TryteAlphabet", "[", "(", "c", "-", "c", "%", "27", ")", "/", "27", "]", ")", "\n", "}", "\n\n", "return", "NewTrytes", "(", "trytesStr", ")", "\n", "}" ]

[ "ASCIIToTrytes", "converts", "an", "ascii", "encoded", "string", "to", "trytes", "." ]

[ "func", "TrytesToASCII", "(", "trytes", "Trytes", ")", "(", "string", ",", "error", ")", "{", "if", "err", ":=", "ValidTrytes", "(", "trytes", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "trytes", ")", "%", "2", "!=", "0", "{", "return", "\"", "\"", ",", "ErrInvalidOddLength", "\n", "}", "\n\n", "ascii", ":=", "\"", "\"", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "trytes", ")", ";", "i", "+=", "2", "{", "ascii", "+=", "string", "(", "strings", ".", "IndexRune", "(", "TryteAlphabet", ",", "rune", "(", "trytes", "[", "i", "]", ")", ")", "+", "(", "strings", ".", "IndexRune", "(", "TryteAlphabet", ",", "rune", "(", "trytes", "[", "i", "+", "1", "]", ")", ")", "*", "27", ")", ")", "\n", "}", "\n\n", "return", "ascii", ",", "nil", "\n", "}" ]

[ "TrytesToASCII", "converts", "trytes", "of", "even", "length", "to", "an", "ascii", "string", "." ]

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

[ "PoWC", "does", "proof", "of", "work", "on", "the", "given", "trytes", "via", "native", "C", "code", "." ]

[ "func", "Digests", "(", "key", "Trits", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "Trits", ",", "error", ")", "{", "var", "err", "error", "\n", "fragments", ":=", "int", "(", "math", ".", "Floor", "(", "float64", "(", "len", "(", "key", ")", ")", "/", "KeyFragmentLength", ")", ")", "\n", "digests", ":=", "make", "(", "Trits", ",", "fragments", "*", "HashTrinarySize", ")", "\n", "buf", ":=", "make", "(", "Trits", ",", "HashTrinarySize", ")", "\n\n", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n", "defer", "h", ".", "Reset", "(", ")", "\n\n", "// iterate through each key fragment", "for", "i", ":=", "0", ";", "i", "<", "fragments", ";", "i", "++", "{", "keyFragment", ":=", "key", "[", "i", "*", "KeyFragmentLength", ":", "(", "i", "+", "1", ")", "*", "KeyFragmentLength", "]", "\n\n", "// each fragment consists of 27 segments", "for", "j", ":=", "0", ";", "j", "<", "KeySegmentsPerFragment", ";", "j", "++", "{", "copy", "(", "buf", ",", "keyFragment", "[", "j", "*", "HashTrinarySize", ":", "(", "j", "+", "1", ")", "*", "HashTrinarySize", "]", ")", "\n\n", "// hash each segment 26 times", "for", "k", ":=", "0", ";", "k", "<", "KeySegmentHashRounds", ";", "k", "++", "{", "h", ".", "Absorb", "(", "buf", ")", "\n", "buf", ",", "err", "=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "h", ".", "Reset", "(", ")", "\n", "}", "\n\n", "copy", "(", "keyFragment", "[", "j", "*", "HashTrinarySize", ":", "]", ",", "buf", ")", "\n", "}", "\n\n", "// hash the key fragment (which now consists of hashed segments)", "if", "err", ":=", "h", ".", "Absorb", "(", "keyFragment", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "buf", ",", "err", ":=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "copy", "(", "digests", "[", "i", "*", "HashTrinarySize", ":", "]", ",", "buf", ")", "\n\n", "h", ".", "Reset", "(", ")", "\n", "}", "\n\n", "return", "digests", ",", "nil", "\n", "}" ]

[ "Digests", "hashes", "each", "segment", "of", "each", "key", "fragment", "26", "times", "and", "returns", "them", ".", "Optionally", "takes", "the", "SpongeFunction", "to", "use", ".", "Default", "is", "Kerl", "." ]

[ "func", "Digest", "(", "normalizedBundleHashFragment", "[", "]", "int8", ",", "signatureFragment", "Trits", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "Trits", ",", "error", ")", "{", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n", "defer", "h", ".", "Reset", "(", ")", "\n\n", "buf", ":=", "make", "(", "Trits", ",", "HashTrinarySize", ")", "\n", "sig", ":=", "make", "(", "Trits", ",", "KeySegmentsPerFragment", "*", "HashTrinarySize", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "KeySegmentsPerFragment", ";", "i", "++", "{", "copy", "(", "buf", ",", "signatureFragment", "[", "i", "*", "HashTrinarySize", ":", "(", "i", "+", "1", ")", "*", "HashTrinarySize", "]", ")", "\n\n", "for", "j", ":=", "normalizedBundleHashFragment", "[", "i", "]", "+", "MaxTryteValue", ";", "j", ">", "0", ";", "j", "--", "{", "err", ":=", "h", ".", "Absorb", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "buf", ",", "err", "=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "h", ".", "Reset", "(", ")", "\n", "}", "\n\n", "copy", "(", "sig", "[", "i", "*", "HashTrinarySize", ":", "(", "i", "+", "1", ")", "*", "HashTrinarySize", "]", ",", "buf", ")", "\n", "}", "\n\n", "if", "err", ":=", "h", ".", "Absorb", "(", "sig", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "Multisig", ")", "Key", "(", "seed", "Trytes", ",", "index", "uint64", ",", "security", "SecurityLevel", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "Trytes", ",", "error", ")", "{", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n\n", "subseed", ",", "err", ":=", "signing", ".", "Subseed", "(", "seed", ",", "index", ",", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "keyTrits", ",", "err", ":=", "signing", ".", "Key", "(", "subseed", ",", "security", ",", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "MustTritsToTrytes", "(", "keyTrits", ")", ",", "nil", "\n", "}" ]

[ "Key", "gets", "the", "key", "value", "of", "a", "seed", "." ]

[ "func", "(", "m", "*", "Multisig", ")", "ValidateAddress", "(", "addr", "Trytes", ",", "digests", "[", "]", "Trytes", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "bool", ",", "error", ")", "{", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n\n", "for", "i", ":=", "range", "digests", "{", "digestTrits", ",", "err", ":=", "TrytesToTrits", "(", "digests", "[", "i", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "err", ":=", "h", ".", "Absorb", "(", "digestTrits", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "}", "\n\n", "addressTrits", ",", "err", ":=", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "MustTritsToTrytes", "(", "addressTrits", ")", "==", "addr", ",", "nil", "\n", "}" ]

[ "ValidateAddress", "validates", "the", "given", "multisig", "address", "." ]

[ "func", "(", "m", "*", "Multisig", ")", "InitiateTransfer", "(", "input", "MultisigInput", ",", "transfers", "bundle", ".", "Transfers", ",", "remainderAddress", "*", "Trytes", ")", "(", "bundle", ".", "Bundle", ",", "error", ")", "{", "if", "err", ":=", "validateMultisigInput", "(", "input", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "Validate", "(", "ValidateTransfers", "(", "transfers", "...", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "remainderAddress", "!=", "nil", "{", "if", "err", ":=", "Validate", "(", "ValidateHashes", "(", "*", "remainderAddress", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "for", "i", ":=", "range", "transfers", "{", "transfer", ":=", "&", "transfers", "[", "i", "]", "\n", "addr", ",", "err", ":=", "checksum", ".", "RemoveChecksum", "(", "transfer", ".", "Address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "transfer", ".", "Address", "=", "addr", "\n", "transfer", ".", "Tag", "=", "bundle", ".", "PadTag", "(", "transfer", ".", "Tag", ")", "\n", "}", "\n\n", "if", "input", ".", "Balance", ">", "0", "{", "return", "createBundle", "(", "input", ",", "transfers", ",", "remainderAddress", ")", "\n", "}", "\n", "balances", ",", "err", ":=", "m", ".", "API", ".", "GetBalances", "(", "Hashes", "{", "input", ".", "Address", "}", ",", "100", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "inputWithBalance", ":=", "MultisigInput", "{", "Balance", ":", "balances", ".", "Balances", "[", "0", "]", ",", "Address", ":", "input", ".", "Address", ",", "SecuritySum", ":", "input", ".", "SecuritySum", ",", "}", "\n\n", "return", "createBundle", "(", "inputWithBalance", ",", "transfers", ",", "remainderAddress", ")", "\n\n", "}" ]

[ "InitiateTransfer", "prepares", "a", "transfer", "by", "generating", "the", "bundle", "with", "the", "corresponding", "cosigner", "transactions", ".", "Does", "not", "contain", "signatures", "." ]

[ "func", "(", "m", "*", "Multisig", ")", "AddSignature", "(", "bndl", "bundle", ".", "Bundle", ",", "inputAddr", "Trytes", ",", "key", "Trytes", ")", "(", "[", "]", "Trytes", ",", "error", ")", "{", "security", ":=", "len", "(", "key", ")", "/", "SignatureMessageFragmentSizeInTrytes", "\n", "keyTrits", ",", "err", ":=", "TrytesToTrits", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "signedFrags", ":=", "[", "]", "Trytes", "{", "}", "\n\n", "numSignedTxs", ":=", "0", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "bndl", ")", ";", "i", "++", "{", "tx", ":=", "&", "bndl", "[", "i", "]", "\n", "if", "tx", ".", "Address", "!=", "inputAddr", "{", "continue", "\n", "}", "\n\n", "if", "!", "guards", ".", "IsEmptyTrytes", "(", "tx", ".", "SignatureMessageFragment", ")", "{", "numSignedTxs", "++", "\n", "continue", "\n", "}", "\n\n", "bundleHash", ":=", "tx", ".", "Bundle", "\n", "firstFrag", ":=", "keyTrits", "[", "0", ":", "6561", "]", "\n", "normalizedBundleHash", ":=", "signing", ".", "NormalizedBundleHash", "(", "bundleHash", ")", "\n", "normalizedBundleFrags", ":=", "[", "]", "[", "]", "int8", "{", "}", "\n\n", "for", "k", ":=", "0", ";", "k", "<", "3", ";", "k", "++", "{", "normalizedBundleFrags", "[", "k", "]", "=", "normalizedBundleHash", "[", "k", "*", "27", ":", "(", "k", "+", "1", ")", "*", "27", "]", "\n", "}", "\n\n", "firstBundleFrag", ":=", "normalizedBundleFrags", "[", "numSignedTxs", "%", "3", "]", "\n", "firstSignedFrag", ",", "err", ":=", "signing", ".", "SignatureFragment", "(", "firstBundleFrag", ",", "firstFrag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "signedFrags", "=", "append", "(", "signedFrags", ",", "MustTritsToTrytes", "(", "firstSignedFrag", ")", ")", "\n\n", "for", "j", ":=", "1", ";", "j", "<", "security", ";", "j", "++", "{", "nextFrag", ":=", "keyTrits", "[", "6561", "*", "j", ":", "(", "j", "+", "1", ")", "*", "6561", "]", "\n", "nextBundleFrag", ":=", "normalizedBundleFrags", "[", "(", "numSignedTxs", "+", "j", ")", "%", "3", "]", "\n", "nextSignedFrag", ",", "err", ":=", "signing", ".", "SignatureFragment", "(", "nextBundleFrag", ",", "nextFrag", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "signedFrags", "=", "append", "(", "signedFrags", ",", "MustTritsToTrytes", "(", "nextSignedFrag", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "signedFrags", ",", "nil", "\n", "}" ]

[ "AddSignature", "returns", "cosigner", "signatures", "for", "the", "transactions", "." ]

[ "func", "NewCurl", "(", "rounds", "...", "CurlRounds", ")", "SpongeFunction", "{", "curlRounds", ":=", "NumberOfRounds", "\n\n", "if", "len", "(", "rounds", ")", ">", "0", "{", "curlRounds", "=", "rounds", "[", "0", "]", "\n", "}", "\n\n", "c", ":=", "&", "Curl", "{", "State", ":", "make", "(", "Trits", ",", "StateSize", ")", ",", "Rounds", ":", "curlRounds", ",", "}", "\n", "return", "c", "\n", "}" ]

[ "NewCurl", "initializes", "a", "new", "instance", "with", "an", "empty", "State", "." ]

[ "func", "(", "c", "*", "Curl", ")", "Squeeze", "(", "length", "int", ")", "(", "Trits", ",", "error", ")", "{", "if", "length", "%", "HashTrinarySize", "!=", "0", "{", "return", "nil", ",", "ErrInvalidSqueezeLength", "\n", "}", "\n\n", "out", ":=", "make", "(", "Trits", ",", "length", ")", "\n", "for", "i", ":=", "1", ";", "i", "<=", "length", "/", "HashTrinarySize", ";", "i", "++", "{", "copy", "(", "out", "[", "HashTrinarySize", "*", "(", "i", "-", "1", ")", ":", "HashTrinarySize", "*", "i", "]", ",", "c", ".", "State", "[", ":", "HashTrinarySize", "]", ")", "\n", "c", ".", "Transform", "(", ")", "\n", "}", "\n\n", "return", "out", ",", "nil", "\n", "}" ]

[ "Squeeze", "squeezes", "out", "trits", "of", "the", "given", "length", ".", "Length", "has", "to", "be", "a", "multiple", "of", "HashTrinarySize", "." ]

[ "func", "(", "c", "*", "Curl", ")", "Absorb", "(", "in", "Trits", ")", "error", "{", "var", "lenn", "int", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "in", ")", ";", "i", "+=", "lenn", "{", "lenn", "=", "HashTrinarySize", "\n\n", "if", "len", "(", "in", ")", "-", "i", "<", "HashTrinarySize", "{", "lenn", "=", "len", "(", "in", ")", "-", "i", "\n", "}", "\n\n", "copy", "(", "c", ".", "State", ",", "in", "[", "i", ":", "i", "+", "lenn", "]", ")", "\n", "c", ".", "Transform", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Absorb", "fills", "the", "internal", "State", "of", "the", "sponge", "with", "the", "given", "trits", "." ]

[ "func", "(", "c", "*", "Curl", ")", "Transform", "(", ")", "{", "if", "transformC", "!=", "nil", "{", "transformC", "(", "c", ".", "State", ",", "int", "(", "c", ".", "Rounds", ")", ")", "\n", "return", "\n", "}", "\n\n", "var", "cpy", "[", "StateSize", "]", "int8", "\n\n", "for", "r", ":=", "c", ".", "Rounds", ";", "r", ">", "0", ";", "r", "--", "{", "copy", "(", "cpy", "[", ":", "]", ",", "c", ".", "State", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "StateSize", ";", "i", "++", "{", "t1", ":=", "Indices", "[", "i", "]", "\n", "t2", ":=", "Indices", "[", "i", "+", "1", "]", "\n", "c", ".", "State", "[", "i", "]", "=", "TruthTable", "[", "cpy", "[", "t1", "]", "+", "(", "cpy", "[", "t2", "]", "<<", "2", ")", "+", "5", "]", "\n", "}", "\n", "}", "\n", "}" ]

[ "Transform", "does", "Transform", "in", "sponge", "func", "." ]

[ "func", "HashTrits", "(", "trits", "Trits", ",", "rounds", "...", "CurlRounds", ")", "(", "Trits", ",", "error", ")", "{", "c", ":=", "NewCurl", "(", "rounds", "...", ")", "\n", "c", ".", "Absorb", "(", "trits", ")", "\n", "return", "c", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "}" ]

[ "HashTrits", "returns", "the", "hash", "of", "the", "given", "trits", "." ]

[ "func", "HashTrytes", "(", "t", "Trytes", ",", "rounds", "...", "CurlRounds", ")", "(", "Trytes", ",", "error", ")", "{", "c", ":=", "NewCurl", "(", "rounds", "...", ")", "\n", "err", ":=", "c", ".", "AbsorbTrytes", "(", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "c", ".", "SqueezeTrytes", "(", "HashTrinarySize", ")", "\n", "}" ]

[ "HashTrytes", "returns", "the", "hash", "of", "the", "given", "trytes", "." ]

[ "func", "MustHashTrytes", "(", "t", "Trytes", ",", "rounds", "...", "CurlRounds", ")", "Trytes", "{", "trytes", ",", "err", ":=", "HashTrytes", "(", "t", ",", "rounds", "...", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "trytes", "\n", "}" ]

[ "MustHashTrytes", "returns", "the", "hash", "of", "the", "given", "trytes", ".", "It", "panics", "if", "the", "given", "trytes", "are", "not", "valid", "." ]

[ "func", "(", "c", "*", "Curl", ")", "Clone", "(", ")", "SpongeFunction", "{", "clone", ":=", "NewCurl", "(", "c", ".", "Rounds", ")", ".", "(", "*", "Curl", ")", "\n", "copy", "(", "clone", ".", "State", ",", "c", ".", "State", ")", "\n", "return", "clone", "\n", "}" ]

[ "Clone", "returns", "a", "deep", "copy", "of", "the", "current", "Curl" ]

[ "func", "NewMultisigAddress", "(", "digests", "Trytes", ",", "spongeFunc", "...", "SpongeFunction", ")", "(", "*", "MultisigAddress", ",", "error", ")", "{", "h", ":=", "GetSpongeFunc", "(", "spongeFunc", ",", "kerl", ".", "NewKerl", ")", "\n\n", "m", ":=", "&", "MultisigAddress", "{", "h", ":", "h", "}", "\n", "if", "len", "(", "digests", ")", "!=", "0", "{", "if", "err", ":=", "m", ".", "Absorb", "(", "digests", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "NewMultisigAddress", "creates", "a", "new", "multisig", "address", "object", "." ]

[ "func", "(", "m", "*", "MultisigAddress", ")", "Absorb", "(", "digests", "...", "Trytes", ")", "error", "{", "for", "i", ":=", "range", "digests", "{", "if", "err", ":=", "m", ".", "h", ".", "Absorb", "(", "MustTrytesToTrits", "(", "digests", "[", "i", "]", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Absorb", "absorbs", "the", "given", "key", "digests", "." ]

[ "func", "(", "m", "*", "MultisigAddress", ")", "Finalize", "(", "digest", "*", "string", ")", "(", "Trytes", ",", "error", ")", "{", "if", "digest", "!=", "nil", "{", "if", "err", ":=", "m", ".", "Absorb", "(", "*", "digest", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "\n\n", "addressTrits", ",", "err", ":=", "m", ".", "h", ".", "Squeeze", "(", "HashTrinarySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "MustTritsToTrytes", "(", "addressTrits", ")", ",", "nil", "\n", "}" ]

[ "Finalize", "finalizes", "and", "returns", "the", "multisig", "address", "as", "trytes", "." ]

[ "func", "Checksum", "(", "address", "Hash", ")", "(", "Trytes", ",", "error", ")", "{", "if", "len", "(", "address", ")", "<", "81", "{", "return", "\"", "\"", ",", "ErrInvalidAddress", "\n", "}", "\n\n", "addressWithChecksum", ",", "err", ":=", "checksum", ".", "AddChecksum", "(", "address", "[", ":", "81", "]", ",", "true", ",", "9", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "addressWithChecksum", "[", "AddressWithChecksumTrytesSize", "-", "AddressChecksumTrytesSize", ":", "90", "]", ",", "nil", "\n", "}" ]

[ "Checksum", "returns", "the", "checksum", "of", "the", "given", "address", "." ]

[ "func", "ValidAddress", "(", "address", "Hash", ")", "error", "{", "switch", "len", "(", "address", ")", "{", "case", "90", ":", "if", "err", ":=", "ValidChecksum", "(", "address", "[", ":", "81", "]", ",", "address", "[", "81", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "81", ":", "default", ":", "return", "ErrInvalidAddress", "\n", "}", "\n", "return", "ValidTrytes", "(", "address", ")", "\n", "}" ]

[ "ValidAddress", "checks", "whether", "the", "given", "address", "is", "valid", "." ]

[ "func", "ValidChecksum", "(", "address", "Hash", ",", "checksum", "Trytes", ")", "error", "{", "actualChecksum", ",", "err", ":=", "Checksum", "(", "address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "checksum", "!=", "actualChecksum", "{", "return", "ErrInvalidChecksum", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidChecksum", "checks", "whether", "the", "given", "checksum", "corresponds", "to", "the", "given", "address", "." ]

[ "func", "GenerateAddress", "(", "seed", "Trytes", ",", "index", "uint64", ",", "secLvl", "SecurityLevel", ",", "addChecksum", "...", "bool", ")", "(", "Hash", ",", "error", ")", "{", "for", "len", "(", "seed", ")", "%", "81", "!=", "0", "{", "seed", "+=", "\"", "\"", "\n", "}", "\n\n", "if", "secLvl", "==", "0", "{", "secLvl", "=", "SecurityLevelMedium", "\n", "}", "\n\n", "subseed", ",", "err", ":=", "Subseed", "(", "seed", ",", "index", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "prvKey", ",", "err", ":=", "Key", "(", "subseed", ",", "secLvl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "digests", ",", "err", ":=", "Digests", "(", "prvKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "addressTrits", ",", "err", ":=", "Address", "(", "digests", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "address", ":=", "MustTritsToTrytes", "(", "addressTrits", ")", "\n\n", "if", "len", "(", "addChecksum", ")", ">", "0", "&&", "addChecksum", "[", "0", "]", "{", "return", "checksum", ".", "AddChecksum", "(", "address", ",", "true", ",", "9", ")", "\n", "}", "\n\n", "return", "address", ",", "nil", "\n", "}" ]

[ "GenerateAddress", "generates", "an", "address", "deterministically", "according", "to", "the", "given", "seed", "index", "and", "security", "level", "." ]

[ "func", "GenerateAddresses", "(", "seed", "Trytes", ",", "start", "uint64", ",", "count", "uint64", ",", "secLvl", "SecurityLevel", ",", "addChecksum", "...", "bool", ")", "(", "Hashes", ",", "error", ")", "{", "addresses", ":=", "make", "(", "Hashes", ",", "count", ")", "\n\n", "var", "withChecksum", "bool", "\n", "if", "len", "(", "addChecksum", ")", ">", "0", "&&", "addChecksum", "[", "0", "]", "{", "withChecksum", "=", "true", "\n", "}", "\n\n", "var", "err", "error", "\n", "for", "i", ":=", "0", ";", "i", "<", "int", "(", "count", ")", ";", "i", "++", "{", "addresses", "[", "i", "]", ",", "err", "=", "GenerateAddress", "(", "seed", ",", "start", "+", "uint64", "(", "i", ")", ",", "secLvl", ",", "withChecksum", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "addresses", ",", "nil", "\n", "}" ]

[ "GenerateAddresses", "generates", "N", "new", "addresses", "from", "the", "given", "seed", "indices", "and", "security", "level", "." ]

[ "func", "TrytesToPendingTransfer", "(", "trytes", "[", "]", "Trytes", ")", "PendingTransfer", "{", "essences", ":=", "make", "(", "[", "]", "Trytes", ",", "len", "(", "trytes", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "trytes", ")", ";", "i", "++", "{", "// if the transaction has a non empty signature message fragment, we store it in the store", "storeSigMsgFrag", ":=", "!", "guards", ".", "IsEmptyTrytes", "(", "trytes", "[", "i", "]", "[", ":", "consts", ".", "AddressTrinaryOffset", "/", "3", "]", ")", "\n", "if", "storeSigMsgFrag", "{", "essences", "[", "i", "]", "=", "trytes", "[", "i", "]", "[", ":", "consts", ".", "BundleTrinaryOffset", "/", "3", "]", "\n", "}", "else", "{", "essences", "[", "i", "]", "=", "trytes", "[", "i", "]", "[", "consts", ".", "AddressTrinaryOffset", "/", "3", ":", "consts", ".", "BundleTrinaryOffset", "/", "3", "]", "\n", "}", "\n", "}", "\n", "return", "PendingTransfer", "{", "Bundle", ":", "essences", ",", "Tails", ":", "Hashes", "{", "}", "}", "\n", "}" ]

[ "TrytesToPendingTransfer", "converts", "the", "given", "trytes", "to", "its", "essence", "trits", "." ]

[ "func", "TransfersToBundleEntries", "(", "timestamp", "uint64", ",", "transfers", "...", "Transfer", ")", "(", "BundleEntries", ",", "error", ")", "{", "entries", ":=", "BundleEntries", "{", "}", "\n", "for", "i", ":=", "range", "transfers", "{", "transfer", ":=", "&", "transfers", "[", "i", "]", "\n", "msgLength", ":=", "len", "(", "transfer", ".", "Message", ")", "\n", "length", ":=", "int", "(", "math", ".", "Ceil", "(", "float64", "(", "msgLength", ")", "/", "SignatureMessageFragmentSizeInTrytes", ")", ")", "\n", "if", "length", "==", "0", "{", "length", "=", "1", "\n", "}", "\n", "addr", ",", "err", ":=", "checksum", ".", "RemoveChecksum", "(", "transfer", ".", "Address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "transfer", ".", "Message", "=", "Pad", "(", "transfer", ".", "Message", ",", "length", "*", "SignatureMessageFragmentSizeInTrytes", ")", "\n\n", "bndlEntry", ":=", "BundleEntry", "{", "Address", ":", "addr", ",", "Value", ":", "int64", "(", "transfer", ".", "Value", ")", ",", "Tag", ":", "transfer", ".", "Tag", ",", "Timestamp", ":", "timestamp", ",", "Length", ":", "uint64", "(", "length", ")", ",", "SignatureMessageFragments", ":", "func", "(", ")", "[", "]", "Trytes", "{", "splitFrags", ":=", "make", "(", "[", "]", "Trytes", ",", "int", "(", "length", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "int", "(", "length", ")", ";", "i", "++", "{", "splitFrags", "[", "i", "]", "=", "transfer", ".", "Message", "[", "i", "*", "SignatureMessageFragmentSizeInTrytes", ":", "(", "i", "+", "1", ")", "*", "SignatureMessageFragmentSizeInTrytes", "]", "\n", "}", "\n", "return", "splitFrags", "\n", "}", "(", ")", ",", "}", "\n\n", "entries", "=", "append", "(", "entries", ",", "bndlEntry", ")", "\n", "}", "\n\n", "return", "entries", ",", "nil", "\n", "}" ]

[ "TransfersToBundleEntries", "translates", "transfers", "to", "bundle", "entries", "." ]