mtproto

type Cipher interface {
	DecryptFromBuffer(k crypto.AuthKey, buf *bin.Buffer) (*crypto.EncryptedMessageData, error)
	Encrypt(key crypto.AuthKey, data crypto.EncryptedMessageData, b *bin.Buffer) error
}

type Conn struct {
	// contains filtered or unexported fields
}

type Dialer func(ctx context.Context) (transport.Conn, error)

type Handler interface {
	OnMessage(b *bin.Buffer) error
	OnSession(session Session) error
}

type MessageBuf interface {
	Consume(id int64) bool
}

type MessageIDSource interface {
	New(t proto.MessageType) int64
}

type NewSessionHandler interface {
	OnNewSession(firstMsgID int64) error
}

type Options struct {
	// DC is datacenter ID for key exchange.
	// Defaults to 2.
	DC int

	// PublicKeys of telegram.
	//
	// If not provided, embedded public keys will be used.
	PublicKeys []exchange.PublicKey

	// Random is random source. Defaults to crypto.
	Random io.Reader
	// Logger is the structured logger. No logs by default.
	Logger log.Logger
	// Handler will be called on received message.
	Handler Handler

	// AckBatchSize is maximum ack-s to buffer.
	AckBatchSize int
	// AckInterval is maximum time to buffer ack.
	AckInterval time.Duration

	// RetryInterval is duration between retries.
	RetryInterval time.Duration
	// MaxRetries is max retry count until rpc request failure.
	MaxRetries int

	// DialTimeout is timeout of creating connection.
	DialTimeout time.Duration
	// ExchangeTimeout is timeout of every key exchange request.
	ExchangeTimeout time.Duration
	// SaltFetchInterval is the duration between get_future_salts requests.
	//
	// Zero (default) never sends get_future_salts, like Telegram Desktop:
	// the server salt is taken from new_session_created and bad_server_salt
	// (a request with an expired salt is re-sent with the new one). A
	// positive value fetches future salts every interval, the first time
	// one interval after the session starts.
	SaltFetchInterval time.Duration
	// PingTimeout is the time to wait for a pong, after which the connection
	// is considered dead. Default is 15 seconds.
	PingTimeout time.Duration
	// PingInterval is the duration between ping_delay_disconnect requests.
	//
	// Zero (default) pings like Telegram Desktop: every 30–45 seconds (a
	// random interval in [30s, 45s]) with disconnect_delay 60. A positive
	// value pings at that fixed interval with disconnect_delay
	// PingInterval + PingTimeout.
	PingInterval time.Duration
	// RequestTimeout is function which returns request timeout for given type ID.
	RequestTimeout func(req uint32) time.Duration

	// CompressThreshold is a threshold in bytes to determine that message
	// is large enough to be compressed using GZIP.
	// If < 0, compression will be disabled.
	// If == 0, default value will be used.
	CompressThreshold int
	// MessageID is message id source. Share source between connection to
	// reduce collision probability.
	MessageID MessageIDSource
	// Clock is current time source. Defaults to system time.
	Clock clock.Clock
	// ServerTime tracks the server time offset; share it between connections
	// of a client. Defaults to a new ServerTime over Clock. Message ids of the
	// default MessageID source and the msg_id time check use it.
	ServerTime *ServerTime
	// Types map, used in verbose logging of incoming message.
	Types *tmap.Map
	// Key that can be used to restore previous connection.
	Key crypto.AuthKey
	// PermKey is permanent auth key for PFS mode.
	PermKey crypto.AuthKey
	// Salt from server that can be used to restore previous connection.
	Salt int64
	// SessionState keeps the server session (session_id and seqno) across
	// reconnects of a connection slot with the same key. Nil starts a new
	// session on every connect. Not used in PFS mode, where every connection
	// has a new temporary key.
	SessionState *SessionState
	// KeyCreatedAt is the creation time of the permanent key (Key, or PermKey
	// in PFS mode), Unix seconds; zero if unknown. It is reported back in
	// Session.KeyCreatedAt and used by the PFS key recovery policy.
	KeyCreatedAt int64

	// EnablePFS enables Perfect Forward Secrecy using temporary auth keys.
	EnablePFS bool
	// TempKeyTTL is temporary auth key lifetime in seconds.
	// Default: 86400 (24h). Minimum: 60.
	TempKeyTTL int

	// Tracer for OTEL.
	Tracer trace.Tracer

	// WireTracer observes plaintext messages and lifecycle events of the
	// connection. Nil (default) disables wire tracing.
	WireTracer WireTracer

	// Cipher defines message crypto.
	Cipher Cipher
	// contains filtered or unexported fields
}

type ServerTime struct {
	// contains filtered or unexported fields
}

type Session struct {
	ID   int64
	Key  crypto.AuthKey
	Salt int64
	// PermKey is non-zero only in PFS mode and is used for bindTempAuthKey.
	PermKey crypto.AuthKey
	// KeyCreatedAt is the creation time of the permanent key (Key, or PermKey
	// in PFS mode), Unix seconds; zero if unknown.
	KeyCreatedAt int64
}

type SessionState struct {
	// contains filtered or unexported fields
}

type WireConn struct {
	// ID is unique for every Conn of the process, starting from 1.
	ID int64
	// DC is the DC id of the connection used for key exchange
	// (Options.DC): 10000 is added for test DCs.
	DC int
}

type WireDirection uint8

type WireEvent struct {
	Type WireEventType
	Conn WireConn

	// AuthKeyID, TempKey and ExpiresAt (unix seconds, temporary keys only)
	// describe the auth key of key events.
	AuthKeyID [8]byte
	TempKey   bool
	ExpiresAt int64

	// Old and New are session ids or salts.
	Old, New int64

	MessageID int64
	SeqNo     int32
	TypeID    uint32
	Latency   time.Duration

	Reason string
	Err    error
}

type WireEventType uint8

type WireMessage struct {
	Conn      WireConn
	Direction WireDirection
	// AuthKeyID is the id of the auth key the message is encrypted with.
	AuthKeyID [8]byte
	// TempKey is true if the message is encrypted with a temporary
	// (PFS) key.
	TempKey   bool
	Salt      int64
	SessionID int64
	MessageID int64
	SeqNo     int32
}

type WireTracer interface {
	// OnMessage is called for every encrypted message: outgoing messages
	// just before encryption and incoming messages after decryption and
	// msg_key check, before session and msg_id checks (rejected messages
	// are reported too, followed by a WireRejected event).
	//
	// The body is the serialized message body as sent or received
	// (including gzip_packed and msg_container). It is only valid during
	// the call: the tracer must not modify or retain it, and must copy it
	// if needed.
	OnMessage(m WireMessage, body []byte)
	// OnEvent is called on connection, key, session and request lifecycle
	// events.
	OnEvent(e WireEvent)
}