func github.com/go-faster/errors.Wrap

402 uses

	github.com/go-faster/errors (current package)
		wrap.go#L81: func Wrap(err error, message string) error {

	github.com/go-faster/jx
		dec_arr.go#L32: 		return false, errors.Wrap(badToken(c, d.offset()), `"[", "," or "]" expected`)
		dec_arr.go#L39: 		return errors.Wrap(err, `"[" expected`)
		dec_arr.go#L49: 		return errors.Wrap(err, `value or "]" expected`)
		dec_arr.go#L56: 		return errors.Wrap(err, "callback")
		dec_arr.go#L61: 		return errors.Wrap(err, `"," or "]" expected`)
		dec_arr.go#L70: 			return errors.Wrap(err, "callback")
		dec_arr.go#L78: 		return errors.Wrap(err, `"]" expected`)
		dec_arr_iter.go#L18: 		return ArrIter{}, errors.Wrap(err, `"[" expected`)
		dec_arr_iter.go#L50: 			i.err = errors.Wrap(err, `"," expected`)
		dec_b64.go#L15: 			return nil, errors.Wrap(err, "read null")
		dec_b64.go#L28: 			return nil, errors.Wrap(err, "read null")
		dec_b64.go#L34: 		return nil, errors.Wrap(err, "bytes")
		dec_b64.go#L43: 		return nil, errors.Wrap(err, "decode")
		dec_float.go#L84: 		return 0, errors.Wrap(err, "double minus")
		dec_float.go#L92: 			return 0, errors.Wrap(err, "leading zero")
		dec_float.go#L184: 		return 0, errors.Wrap(err, "double minus")
		dec_float.go#L192: 			return 0, errors.Wrap(err, "leading zero")
		dec_float.go#L269: 		return 0, errors.Wrap(err, "number")
		dec_float.go#L297: 		return errors.Wrap(err, "double minus")
		dec_float.go#L304: 				return errors.Wrap(err, "leading zero")
		dec_float.go#L319: 			return errors.Wrap(err, "no digit after dot")
		dec_float_big.go#L14: 		return nil, errors.Wrap(err, "number")
		dec_float_big.go#L22: 		return nil, errors.Wrap(err, "float")
		dec_float_big.go#L31: 		return nil, errors.Wrap(err, "number")
		dec_int.gen.go#L41: 				return 0, errors.Wrap(err, "digit after leading zero")
		dec_int.gen.go#L44: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L68: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L85: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L103: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L128: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L203: 				return 0, errors.Wrap(err, "digit after leading zero")
		dec_int.gen.go#L206: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L230: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L247: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L265: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L284: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L304: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L333: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L408: 				return 0, errors.Wrap(err, "digit after leading zero")
		dec_int.gen.go#L411: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L435: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L452: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L470: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L489: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L509: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L530: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L552: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L575: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L599: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L636: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L711: 				return 0, errors.Wrap(err, "digit after leading zero")
		dec_int.gen.go#L714: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L738: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L755: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L773: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L792: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L812: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L833: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L855: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L878: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L902: 			return 0, errors.Wrap(err, "unexpected floating point character")
		dec_int.gen.go#L939: 				return 0, errors.Wrap(err, "unexpected floating point character")
		dec_num.go#L28: 			return Num{}, errors.Wrap(err, "str")
		dec_num.go#L45: 					return Num{}, errors.Wrap(err, "skip number")
		dec_obj.go#L12: 		return errors.Wrap(err, `"{" expected`)
		dec_obj.go#L22: 		return errors.Wrap(err, `'"' or "}" expected`)
		dec_obj.go#L37: 		return errors.Wrap(err, "field name")
		dec_obj.go#L40: 		return errors.Wrap(err, `":" expected`)
		dec_obj.go#L48: 		return errors.Wrap(err, "callback")
		dec_obj.go#L53: 		return errors.Wrap(err, `"," or "}" expected`)
		dec_obj.go#L58: 			return errors.Wrap(err, "field name")
		dec_obj.go#L61: 			return errors.Wrap(err, `":" expected`)
		dec_obj.go#L69: 			return errors.Wrap(err, "callback")
		dec_obj.go#L77: 		return errors.Wrap(err, `"}" expected`)
		dec_obj_iter.go#L18: 		return ObjIter{}, errors.Wrap(err, `"{" expected`)
		dec_obj_iter.go#L57: 			i.err = errors.Wrap(err, `"," expected`)
		dec_obj_iter.go#L66: 		i.err = errors.Wrap(err, "field name")
		dec_obj_iter.go#L70: 		i.err = errors.Wrap(err, `":" expected`)
		dec_obj_iter.go#L76: 		i.err = errors.Wrap(err, `"," or "}" expected`)
		dec_raw.go#L47: 			return nil, errors.Wrap(err, "skip")
		dec_raw.go#L57: 		return nil, errors.Wrap(err, "skip")
		dec_skip.go#L18: 			return errors.Wrap(err, "str")
		dec_skip.go#L33: 			return errors.Wrap(err, "array")
		dec_skip.go#L38: 			return errors.Wrap(err, "object")
		dec_skip.go#L380: 		return errors.Wrap(err, "inc")
		dec_skip.go#L385: 		return errors.Wrap(err, `'"' or "}" expected`)
		dec_skip.go#L398: 			return errors.Wrap(err, `'"' expected`)
		dec_skip.go#L401: 			return errors.Wrap(err, "read field name")
		dec_skip.go#L404: 			return errors.Wrap(err, `":" expected`)
		dec_skip.go#L411: 			return errors.Wrap(err, `"," or "}" expected`)
		dec_skip.go#L429: 		return errors.Wrap(err, "inc")
		dec_skip.go#L434: 		return errors.Wrap(err, `value or "]" expected`)
		dec_skip.go#L447: 			return errors.Wrap(err, `"," or "]" expected`)
		dec_str.go#L219: 			return v, errors.Wrap(err, "escape")
		dec_str.go#L254: 			return value{}, errors.Wrap(err, "read u4")
		dec_str.go#L287: 		return v, errors.Wrap(err, "bad escape")
		dec_validate.go#L14: 		return errors.Wrap(err, "consume")
		dec_validate.go#L18: 		return errors.Wrap(err, "unexpected trialing data")
		num.go#L67: 		return 0, errors.Wrap(err, "float as int")
		num.go#L103: 		return 0, errors.Wrap(err, "float as int")

	github.com/gotd/td/internal/crypto
		encrypted_message_data.go#L49: 		return errors.Wrap(err, "encode inner message")
		exchange.go#L20: 		return nil, errors.Wrap(err, "create aes cipher")
		exchange.go#L45: 		return nil, errors.Wrap(err, "create aes cipher")
		exchange.go#L50: 		return nil, errors.Wrap(err, "get answer with hash")
		key.go#L66: 				return errors.Wrap(err, "decode value")
		key.go#L72: 				return errors.Wrap(err, "decode id")
		public_keys.go#L23: 			return nil, errors.Wrap(err, "parse RSA from PEM")
		rsa_pad.go#L50: 		return nil, errors.Wrap(err, "pad data with random")
		rsa_pad.go#L63: 			return nil, errors.Wrap(err, "generate temp_key")
		rsa_pad.go#L83: 				return nil, errors.Wrap(err, "create cipher")
		rsa_pad.go#L142: 			return nil, errors.Wrap(err, "create cipher")

	github.com/gotd/td/internal/crypto/srp
		hash.go#L18: 		return Answer{}, errors.Wrap(err, "validate algo")
		new_hash.go#L39: 		return nil, nil, errors.Wrap(err, "validate algo")

	github.com/gotd/td/internal/exchange
		client_flow.go#L22: 		return ClientExchangeResult{}, errors.Wrap(err, "client nonce generation")
		client_flow.go#L28: 		return ClientExchangeResult{}, errors.Wrap(err, "write ReqPqMultiRequest")
		client_flow.go#L35: 		return ClientExchangeResult{}, errors.Wrap(err, "read ResPQ response")
		client_flow.go#L74: 		return ClientExchangeResult{}, errors.Wrap(err, "decompose pq")
		client_flow.go#L86: 		return ClientExchangeResult{}, errors.Wrap(err, "generate new nonce")
		client_flow.go#L107: 		return ClientExchangeResult{}, errors.Wrap(err, "encrypted_data generation")
		client_flow.go#L122: 		return ClientExchangeResult{}, errors.Wrap(err, "write ReqDHParamsRequest")
		client_flow.go#L127: 		return ClientExchangeResult{}, errors.Wrap(err, "read ServerDHParams message")
		client_flow.go#L133: 		return ClientExchangeResult{}, errors.Wrap(err, "decode ServerDHParams message")
		client_flow.go#L155: 			return ClientExchangeResult{}, errors.Wrap(err, "exchange answer decrypt")
		client_flow.go#L173: 			return ClientExchangeResult{}, errors.Wrap(err, "check DH params")
		client_flow.go#L181: 			return ClientExchangeResult{}, errors.Wrap(err, "number b generation")
		client_flow.go#L188: 			return ClientExchangeResult{}, errors.Wrap(err, "key exchange failed: invalid params")
		client_flow.go#L204: 			return ClientExchangeResult{}, errors.Wrap(err, "exchange answer encrypt")
		client_flow.go#L214: 			return ClientExchangeResult{}, errors.Wrap(err, "write SetClientDHParamsRequest")
		client_flow.go#L222: 			return ClientExchangeResult{}, errors.Wrap(err, "read DhGen message")
		client_flow.go#L227: 			return ClientExchangeResult{}, errors.Wrap(err, "decode DhGen message")
		client_flow.go#L232: 			return ClientExchangeResult{}, errors.Wrap(err, "decode DhGen answer")
		generator.go#L31: 		return nil, errors.Wrap(err, "decode hex string")
		server_flow.go#L114: 		return ServerExchangeResult{}, errors.Wrap(err, "generate server nonce")
		server_flow.go#L122: 		return ServerExchangeResult{}, errors.Wrap(err, "generate pq")
		server_flow.go#L191: 		return ServerExchangeResult{}, errors.Wrap(err, "generate dh_prime")
		server_flow.go#L197: 		return ServerExchangeResult{}, errors.Wrap(err, "generate g_a")
		server_flow.go#L238: 		err = errors.Wrap(err, "decrypt exchange answer")

	github.com/gotd/td/internal/mtproto
		ack.go#L33: 			return errors.Wrap(ctx.Err(), "acl")
		conn.go#L201: 		return errors.Wrap(err, "start")
		conn.go#L214: 			return errors.Wrap(err, "group")
		connect.go#L21: 		return errors.Wrap(err, "dial failed")
		connect.go#L35: 			return errors.Wrap(err, "create auth key")
		handle_ack.go#L14: 		return errors.Wrap(err, "decode")
		handle_container.go#L14: 		return errors.Wrap(err, "container")
		handle_future_salts.go#L17: 		return errors.Wrap(err, "error decode")
		handle_gzip.go#L13: 		return nil, errors.Wrap(err, "decode")
		handle_gzip.go#L21: 		return errors.Wrap(err, "unzip")
		handle_message.go#L16: 		return errors.Wrap(err, "peek message type")
		handle_result.go#L17: 		return errors.Wrap(err, "decode")
		handle_result.go#L34: 			return errors.Wrap(err, "decompress")
		handle_result.go#L43: 			return errors.Wrap(err, "peek id")
		handle_result.go#L50: 			return errors.Wrap(err, "error decode")
		handle_session_created.go#L15: 		return errors.Wrap(err, "decode")
		handle_session_created.go#L37: 		return errors.Wrap(err, "handler.OnSession")
		new_encrypted_msg.go#L38: 			return errors.Wrap(err, "encode payload")
		new_encrypted_msg.go#L64: 		return errors.Wrap(err, "encrypt")
		ping.go#L27: 		return errors.Wrap(err, "write")
		ping.go#L71: 		return errors.Wrap(err, "write")
		ping.go#L107: 			return errors.Wrap(ctx.Err(), "ping loop")
		ping.go#L115: 				return errors.Wrap(err, "disconnect (pong missed)")
		read.go#L43: 		return errors.Wrap(errRejected, "created too far in past")
		read.go#L46: 		return errors.Wrap(errRejected, "created too far in future")
		read.go#L56: 		return nil, errors.Wrap(err, "decrypt")
		read.go#L80: 		return errors.Wrap(err, "consume message")
		read.go#L125: 		return errors.Wrap(err, "unable to create auth key")
		read.go#L167: 			return errors.Wrap(err, "halting")
		read.go#L183: 					return errors.Wrap(err, "auth key not found")
		read.go#L191: 				return errors.Wrap(ctx.Err(), "read loop")
		read.go#L193: 				return errors.Wrap(err, "read")
		read.go#L209: 				lastErr.Store(errors.Wrap(err, "consume"))
		rpc.go#L44: 		return errors.Wrap(err, "rpcDoRequest")
		salt.go#L44: 		return errors.Wrap(err, "request salts")

	github.com/gotd/td/internal/mtproxy/faketls
		client_hello.go#L110: 		return [32]byte{}, errors.Wrap(err, "hmac write")
		faketls.go#L46: 		return errors.Wrap(err, "generate sessionID")
		faketls.go#L51: 		return errors.Wrap(err, "send ClientHello")
		faketls.go#L55: 		return errors.Wrap(err, "receive ServerHello")
		faketls.go#L72: 			return 0, errors.Wrap(err, "write first TLS packet")
		faketls.go#L82: 		return 0, errors.Wrap(err, "write TLS record")
		faketls.go#L98: 		return 0, errors.Wrap(err, "read TLS record")
		record.go#L62: 		return 0, errors.Wrap(err, "type and version")
		record.go#L67: 		return 0, errors.Wrap(err, "data length")
		record.go#L72: 		return 0, errors.Wrap(err, "data")
		server_hello.go#L19: 		return errors.Wrap(err, "handshake record")
		server_hello.go#L22: 		return errors.Wrap(err, "unexpected record type")
		server_hello.go#L27: 		return errors.Wrap(err, "change cipher record")
		server_hello.go#L30: 		return errors.Wrap(err, "unexpected record type")
		server_hello.go#L35: 		return errors.Wrap(err, "cert record")
		server_hello.go#L38: 		return errors.Wrap(err, "unexpected record type")
		server_hello.go#L55: 		return errors.Wrap(err, "hmac write")
		server_hello.go#L58: 		return errors.Wrap(err, "hmac write")

	github.com/gotd/td/internal/mtproxy/obfuscated2
		obfuscated2.go#L31: 		return errors.Wrap(err, "generate keys")
		obfuscated2.go#L36: 		return errors.Wrap(err, "write obfuscated header")

	github.com/gotd/td/internal/mtproxy/obfuscator
		obfuscator.go#L44: 		return errors.Wrap(err, "faketls handshake")
		obfuscator.go#L48: 		return errors.Wrap(err, "obfs2 handshake")

	github.com/gotd/td/internal/pool
		pool.go#L186: 			return nil, errors.Wrap(c.ctx.Err(), "DC closed")
		pool.go#L223: 		err = errors.Wrap(c.ctx.Err(), "DC closed")
		pool.go#L251: 			return errors.Wrap(err, "acquire connection")
		pool.go#L259: 			return errors.Wrap(err, "invoke pool")

	github.com/gotd/td/internal/proto
		container.go#L32: 		return errors.Wrap(err, "consume id of message container")
		gzip.go#L94: 			closeErr = errors.Wrap(closeErr, "close")
		gzip.go#L100: 		return errors.Wrap(err, "compress")
		gzip.go#L103: 		return errors.Wrap(err, "close")
		gzip.go#L153: 		return errors.Wrap(err, "gzip error")
		gzip.go#L157: 			closeErr = errors.Wrap(closeErr, "close")
		gzip.go#L169: 		return errors.Wrap(err, "decompress")
		gzip.go#L173: 		return errors.Wrap(&DecompressionBombErr{
		gzip.go#L180: 		return errors.Wrap(err, "checksum")
		unencrypted_message.go#L42: 		return errors.Wrap(err, "consume payload")

	github.com/gotd/td/internal/proto/codec
		abridged.go#L29: 		return errors.Wrap(err, "write abridged header")
		abridged.go#L39: 		return errors.Wrap(err, "read abridged header")
		abridged.go#L66: 		return errors.Wrap(err, "write abridged")
		abridged.go#L75: 		return errors.Wrap(err, "read abridged")
		abridged.go#L141: 		return errors.Wrap(err, "read payload")
		codec.go#L35: 		return 0, errors.Wrap(err, "read length")
		full.go#L38: 		return errors.Wrap(err, "write full")
		full.go#L47: 		return errors.Wrap(err, "read full")
		full.go#L80: 		return errors.Wrap(err, "len")
		full.go#L91: 		return errors.Wrap(err, "read seqno, buffer and crc")
		intermediate.go#L28: 		return errors.Wrap(err, "write intermediate header")
		intermediate.go#L38: 		return errors.Wrap(err, "read intermediate header")
		intermediate.go#L64: 		return errors.Wrap(err, "write intermediate")
		intermediate.go#L73: 		return errors.Wrap(err, "read intermediate")
		intermediate.go#L106: 		return errors.Wrap(err, "read payload")
		padded_intermediate.go#L29: 		return errors.Wrap(err, "write padded intermediate header")
		padded_intermediate.go#L39: 		return errors.Wrap(err, "read padded intermediate header")
		padded_intermediate.go#L65: 		return errors.Wrap(err, "write padded intermediate")
		padded_intermediate.go#L74: 		return errors.Wrap(err, "read padded intermediate")

	github.com/gotd/td/internal/rpc
		engine.go#L141: 		return errors.Wrap(err, "retryUntilAck")
		engine.go#L168: 		return errors.Wrap(e.reqCtx.Err(), "engine forcibly closed")
		engine.go#L192: 		return false, errors.Wrap(err, "send")
		engine.go#L204: 				return errors.Wrap(e.reqCtx.Err(), "engine forcibly closed")

	github.com/gotd/td/session
		session.go#L127: 		return nil, errors.Wrap(err, "load")
		session.go#L135: 		return nil, errors.Wrap(err, "unmarshal")
		session.go#L152: 		return errors.Wrap(err, "marshal")
		session.go#L155: 		return errors.Wrap(err, "store")
		storage_file.go#L32: 		return nil, errors.Wrap(err, "read")
		storage_mem.go#L33: 		return errors.Wrap(err, "write session")
		telethon.go#L37: 		return nil, errors.Wrap(err, "decode hex")

	github.com/gotd/td/session/tdesktop
		dbi.go#L98: 		return qtReader{}, errors.Wrap(err, "read length")
		file.go#L27: 			return nil, errors.Wrap(err, "open")
		file.go#L41: 			return nil, errors.Wrap(err, "stat")
		file.go#L54: 			return nil, errors.Wrap(err, "read tdesktop file")
		file.go#L70: 		return nil, errors.Wrap(err, "read magic and version")
		file.go#L85: 		return nil, errors.Wrap(err, "read data")
		file.go#L107: 		return errors.Wrap(err, "write magic")
		file.go#L110: 		return errors.Wrap(err, "write version")
		file.go#L113: 		return errors.Wrap(err, "write data")
		file.go#L117: 		return errors.Wrap(err, "write hash")
		file.go#L169: 		return errors.Wrap(err, "write length")
		file.go#L173: 		return errors.Wrap(err, "write data")
		key_data.go#L20: 		return keyData{}, errors.Wrap(err, "read salt")
		key_data.go#L29: 		return keyData{}, errors.Wrap(err, "read keyEncrypted")
		key_data.go#L33: 		return keyData{}, errors.Wrap(err, "decrypt keyEncrypted")
		key_data.go#L37: 		return keyData{}, errors.Wrap(err, "read key")
		key_data.go#L48: 		return keyData{}, errors.Wrap(err, "read infoEncrypted")
		local_key.go#L59: 		return nil, errors.Wrap(err, "create cipher")
		local_key.go#L84: 		return nil, errors.Wrap(err, "create cipher")
		mtp_authorization.go#L26: 		return MTPAuthorization{}, errors.Wrap(err, "read encrypted data")
		mtp_authorization.go#L31: 		return MTPAuthorization{}, errors.Wrap(err, "decrypt data")
		mtp_authorization.go#L40: 		return MTPAuthorization{}, errors.Wrap(err, "deserialize MTPAuthorization")
		mtp_authorization.go#L48: 		return 0, errors.Wrap(err, "read DC ID")
		mtp_authorization.go#L52: 		return 0, errors.Wrap(err, "read auth key")
		mtp_authorization.go#L61: 		return errors.Wrap(err, "read dbi ID")
		mtp_authorization.go#L68: 		return errors.Wrap(err, "read mainLength")
		mtp_authorization.go#L73: 		return errors.Wrap(err, "read legacyUserID")
		mtp_authorization.go#L77: 		return errors.Wrap(err, "read legacyMainDCID")
		mtp_authorization.go#L82: 			return errors.Wrap(err, "read userID")
		mtp_authorization.go#L86: 			return errors.Wrap(err, "read mainDcID")
		mtp_authorization.go#L98: 		return errors.Wrap(err, "read keys length")
		mtp_config.go#L76: 		return MTPConfig{}, errors.Wrap(err, "read encrypted data")
		mtp_config.go#L81: 		return MTPConfig{}, errors.Wrap(err, "decrypt data")
		mtp_config.go#L89: 		return MTPConfig{}, errors.Wrap(err, "read config array")
		mtp_config.go#L94: 		return MTPConfig{}, errors.Wrap(err, "deserialize MTPConfig")
		mtp_config.go#L102: 		return errors.Wrap(err, "read version")
		mtp_config.go#L110: 		return errors.Wrap(err, "read environment")
		mtp_config.go#L123: 			return errors.Wrap(err, "read DC options")
		mtp_config.go#L129: 		return errors.Wrap(err, "read chatSizeMax")
		mtp_config.go#L135: 		return errors.Wrap(err, "read megagroupSizeMax")
		mtp_config.go#L141: 		return errors.Wrap(err, "read forwardedCountMax")
		mtp_config.go#L147: 		return errors.Wrap(err, "read onlineUpdatePeriod")
		mtp_config.go#L153: 		return errors.Wrap(err, "read offlineBlurTimeout")
		mtp_config.go#L159: 		return errors.Wrap(err, "read offlineIdleTimeout")
		mtp_config.go#L165: 		return errors.Wrap(err, "read onlineFocusTimeout")
		mtp_config.go#L171: 		return errors.Wrap(err, "read onlineCloudTimeout")
		mtp_config.go#L177: 		return errors.Wrap(err, "read notifyCloudDelay")
		mtp_config.go#L183: 		return errors.Wrap(err, "read notifyDefaultDelay")
		mtp_config.go#L189: 		return errors.Wrap(err, "read savedGifsLimit")
		mtp_config.go#L195: 		return errors.Wrap(err, "read editTimeLimit")
		mtp_config.go#L201: 		return errors.Wrap(err, "read revokeTimeLimit")
		mtp_config.go#L207: 		return errors.Wrap(err, "read revokePrivateTimeLimit")
		mtp_config.go#L213: 		return errors.Wrap(err, "read revokePrivateInbox")
		mtp_config.go#L219: 		return errors.Wrap(err, "read stickersRecentLimit")
		mtp_config.go#L225: 		return errors.Wrap(err, "read stickersFavedLimit")
		mtp_config.go#L231: 		return errors.Wrap(err, "read pinnedDialogsCountMax")
		mtp_config.go#L237: 		return errors.Wrap(err, "read pinnedDialogsInFolderMax")
		mtp_config.go#L243: 		return errors.Wrap(err, "read internalLinksDomain")
		mtp_config.go#L249: 		return errors.Wrap(err, "read channelsReadMediaPeriod")
		mtp_config.go#L255: 		return errors.Wrap(err, "read callReceiveTimeoutMs")
		mtp_config.go#L261: 		return errors.Wrap(err, "read callRingTimeoutMs")
		mtp_config.go#L267: 		return errors.Wrap(err, "read callConnectTimeoutMs")
		mtp_config.go#L273: 		return errors.Wrap(err, "read callPacketTimeoutMs")
		mtp_config.go#L279: 		return errors.Wrap(err, "read webFileDCID")
		mtp_config.go#L285: 		return errors.Wrap(err, "read txtDomainString")
		mtp_config.go#L291: 		return errors.Wrap(err, "read phoneCallsEnabled")
		mtp_config.go#L297: 		return errors.Wrap(err, "read blockedMode")
		mtp_config.go#L303: 		return errors.Wrap(err, "read captionLengthMax")
		mtp_dcoptions.go#L48: 		return errors.Wrap(err, "read id")
		mtp_dcoptions.go#L54: 		return errors.Wrap(err, "read flags")
		mtp_dcoptions.go#L60: 		return errors.Wrap(err, "read port")
		mtp_dcoptions.go#L67: 		return errors.Wrap(err, "read ip")
		mtp_dcoptions.go#L78: 			return errors.Wrap(err, "read secret")
		mtp_dcoptions.go#L99: 		return errors.Wrap(err, "read version")
		mtp_dcoptions.go#L111: 			return errors.Wrap(err, "read count")
		tdesktop.go#L35: 		return nil, errors.Wrap(err, "open key_data")
		tdesktop.go#L55: 			return nil, errors.Wrap(err, "open key_data")
		tdesktop.go#L60: 			return nil, errors.Wrap(err, "read mtp")

	github.com/gotd/td/telegram
		bot.go#L30: 		return errors.Wrap(err, "create client")
		bot.go#L35: 			return errors.Wrap(err, "setup")
		bot.go#L42: 			return errors.Wrap(err, "auth status")
		bot.go#L47: 				return errors.Wrap(err, "login")
		builder.go#L53: 				return Options{}, errors.Wrap(err, "SESSION_DIR not set or invalid")
		builder.go#L60: 			return Options{}, errors.Wrap(err, "session dir creation")
		builder.go#L87: 		return nil, errors.Wrap(err, "APP_ID not set or invalid")
		builder.go#L168: 				return errors.Wrap(err, "auth flow")
		cdn.go#L24: 			return nil, errors.Wrap(err, "parse RSA from PEM")
		connect.go#L105: 			return errors.Wrap(c.ctx.Err(), "client already closed")
		connect.go#L151: 				return errors.Wrap(err, "callback")
		handle_updates.go#L51: 		return errors.Wrap(err, "decode updates")
		migrate_to_dc.go#L52: 		return errors.Wrap(err, "migrate to dc")
		pool.go#L27: 		return nil, errors.Wrap(c.ctx.Err(), "client already closed")
		pool.go#L94: 		return nil, errors.Wrap(err, "create pool")
		pool.go#L106: 		return nil, errors.Wrap(err, "transfer")
		session.go#L27: 		return errors.Wrap(err, "load")
		session.go#L75: 		return errors.Wrap(err, "load")
		session.go#L86: 		return errors.Wrap(err, "save")
		session.go#L121: 		return errors.Wrap(err, "save")

	github.com/gotd/td/telegram/auth
		bot.go#L23: 		return nil, errors.Wrap(err, "check")
		flow.go#L33: 		return errors.Wrap(err, "confirm TOS")
		flow.go#L37: 		return errors.Wrap(err, "sign up info not provided")
		flow.go#L45: 		return errors.Wrap(err, "sign up")
		flow.go#L58: 		return errors.Wrap(err, "get phone")
		flow.go#L63: 		return errors.Wrap(err, "send code")
		flow.go#L70: 			return errors.Wrap(err, "get code")
		flow.go#L77: 				return errors.Wrap(err, "get password")
		flow.go#L80: 				return errors.Wrap(err, "sign in with password")
		flow.go#L90: 			return errors.Wrap(signInErr, "sign in")
		flow.go#L104: 				return errors.Wrap(err, "sign up after auth sent code success")
		password.go#L33: 		return nil, errors.Wrap(err, "create SRP answer")
		password.go#L56: 		return nil, errors.Wrap(err, "create SRP answer")
		password.go#L87: 		return errors.Wrap(err, "get SRP parameters")
		password.go#L97: 		return errors.Wrap(err, "compute new password hash")
		password.go#L108: 			return errors.Wrap(err, "get password")
		password.go#L113: 			return errors.Wrap(err, "compute old password hash")
		password.go#L126: 		return errors.Wrap(err, "update password")
		password.go#L157: 		return time.Time{}, errors.Wrap(err, "reset password")
		password.go#L176: 		return errors.Wrap(err, "cancel password reset")
		status.go#L39: 		return errors.Wrap(err, "get auth status")
		status.go#L45: 		return errors.Wrap(err, "auth flow")
		user.go#L25: 		return nil, errors.Wrap(err, "get SRP parameters")
		user.go#L30: 		return nil, errors.Wrap(err, "compute password hash")
		user.go#L42: 		return nil, errors.Wrap(err, "check password")
		user.go#L46: 		return nil, errors.Wrap(err, "check")
		user.go#L86: 		return nil, errors.Wrap(err, "send code")
		user.go#L112: 		return nil, errors.Wrap(err, "sign in")
		user.go#L116: 		return nil, errors.Wrap(err, "check")
		user.go#L147: 		return nil, errors.Wrap(err, "request")
		user.go#L151: 		return nil, errors.Wrap(err, "check")

	github.com/gotd/td/telegram/auth/qrlogin
		accept.go#L17: 		return nil, errors.Wrap(err, "accept")
		qrlogin.go#L47: 		return Token{}, errors.Wrap(err, "export")
		qrlogin.go#L73: 		return nil, errors.Wrap(err, "import")
		qrlogin.go#L84: 			return nil, errors.Wrap(err, "migrate")
		qrlogin.go#L89: 			return nil, errors.Wrap(err, "import")
		qrlogin.go#L155: 			return nil, errors.Wrap(err, "show")
		token.go#L73: 		return nil, errors.Wrap(err, "encode")

	github.com/gotd/td/telegram/dcs
		dns.go#L168: 		return DNSConfig{}, errors.Wrap(err, "decode")
		dns.go#L173: 		return DNSConfig{}, errors.Wrap(err, "decrypt config")
		mtproxy.go#L53: 		err = errors.Wrap(err, "handshake")
		mtproxy.go#L74: 		return nil, errors.Wrap(err, "MTProxy handshake")
		mtproxy.go#L79: 		return nil, errors.Wrap(err, "transport handshake")
		plain.go#L95: 			return nil, errors.Wrap(err, "check DC secret")
		plain.go#L118: 		return nil, errors.Wrap(err, "transport handshake")
		websocket.go#L39: 		return nil, errors.Wrap(err, "dial ws")
		websocket.go#L47: 		return nil, errors.Wrap(err, "handshake")
		websocket.go#L52: 		return nil, errors.Wrap(err, "transport handshake")

	github.com/gotd/td/telegram/internal/manager
		conn.go#L161: 		return errors.Wrap(err, "waitSession")
		conn.go#L218: 				return errors.Wrap(err, "flood wait")
		conn.go#L221: 			return backoff.Permanent(errors.Wrap(err, "invoke"))
		conn.go#L230: 		return errors.Wrap(err, "initConnection")
		conn.go#L235: 			return errors.Wrap(err, "setup")

	github.com/gotd/td/transport
		connection.go#L39: 		return errors.Wrap(err, "reset write deadline")
		connection.go#L43: 			return errors.Wrap(err, "set write deadline")
		connection.go#L48: 		return errors.Wrap(err, "write")
		connection.go#L61: 		return errors.Wrap(err, "reset read deadline")
		connection.go#L65: 			return errors.Wrap(err, "set read deadline")
		connection.go#L70: 		return errors.Wrap(err, "read")
		detect_codec.go#L15: 		return nil, nil, errors.Wrap(err, "read first byte")
		detect_codec.go#L23: 		return nil, nil, errors.Wrap(err, "read header")
		listener.go#L59: 			return nil, errors.Wrap(err, "read header")
		listener.go#L71: 		return nil, errors.Wrap(err, "detect codec")
		obfuscated.go#L56: 		return nil, errors.Wrap(err, "accept")
		protocol.go#L66: 		return nil, errors.Wrap(err, "write header")

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.