Remove wrap prefix

client/middle.go

 	if err != nil {
 		return nil, nil, err
 	}
-	connStream := conn.(wrappers.WrapStreamReadWriteCloser)
+	connStream := conn.(wrappers.StreamReadWriteCloser)
 
 	newConn := wrappers.NewMTProtoAbridged(connStream, opts)
 	if opts.ConnectionType != mtproto.ConnectionTypeAbridged {

proxy/proxy.go

 		log.Errorw("Cannot initialize client connection", "error", err)
 		return
 	}
-	defer client.(wrappers.WrapCloser).Close()
+	defer client.(io.Closer).Close()
 
 	server, err := p.getTelegramConn(ctx, cancel, opts, connID)
 	if err != nil {
 		log.Errorw("Cannot initialize server connection", "error", err)
 		return
 	}
-	defer server.(wrappers.WrapCloser).Close()
+	defer server.(io.Closer).Close()
 
 	wait := &sync.WaitGroup{}
 	wait.Add(2)
 
 	if p.conf.UseMiddleProxy() {
-		clientPacket := client.(wrappers.WrapPacketReadWriteCloser)
-		serverPacket := server.(wrappers.WrapPacketReadWriteCloser)
+		clientPacket := client.(wrappers.PacketReadWriteCloser)
+		serverPacket := server.(wrappers.PacketReadWriteCloser)
 		go p.middlePipe(clientPacket, serverPacket, wait, &opts.ReadHacks)
 		go p.middlePipe(serverPacket, clientPacket, wait, &opts.WriteHacks)
 	} else {
-		clientStream := client.(wrappers.WrapStreamReadWriteCloser)
-		serverStream := server.(wrappers.WrapStreamReadWriteCloser)
+		clientStream := client.(wrappers.StreamReadWriteCloser)
+		serverStream := server.(wrappers.StreamReadWriteCloser)
 		go p.directPipe(clientStream, serverStream, wait)
 		go p.directPipe(serverStream, clientStream, wait)
 	}
 	return packetConn, nil
 }
 
-func (p *Proxy) middlePipe(src wrappers.WrapPacketReader, dst wrappers.WrapPacketWriter, wait *sync.WaitGroup, hacks *mtproto.Hacks) {
+func (p *Proxy) middlePipe(src wrappers.PacketReader, dst wrappers.PacketWriter, wait *sync.WaitGroup, hacks *mtproto.Hacks) {
 	defer wait.Done()
-
 	for {
 		hacks.SimpleAck = false
 		hacks.QuickAck = false

telegram/dialer.go

 	return conn, nil
 }
 
-func (t *tgDialer) dialRWC(addr, connID string) (wrappers.WrapStreamReadWriteCloser, error) {
+func (t *tgDialer) dialRWC(addr, connID string) (wrappers.StreamReadWriteCloser, error) {
 	conn, err := t.dial(addr)
 	if err != nil {
 		return nil, err
 	}
-
-	tgConn := wrappers.NewConn(conn, connID, wrappers.ConnPurposeTelegram,
-		t.conf.PublicIPv4, t.conf.PublicIPv6)
+	tgConn := wrappers.NewConn(conn, connID, wrappers.ConnPurposeTelegram, t.conf.PublicIPv4, t.conf.PublicIPv6)
 
 	return tgConn, nil
 }

telegram/direct.go

 	baseTelegram
 }
 
-func (t *DirectTelegram) Dial(connID string, connOpts *mtproto.ConnectionOpts) (wrappers.WrapStreamReadWriteCloser, error) {
+func (t *DirectTelegram) Dial(connID string, connOpts *mtproto.ConnectionOpts) (wrappers.StreamReadWriteCloser, error) {
 	dc := connOpts.DC
 	if dc < 0 {
 		dc = -dc
 	return t.baseTelegram.dial(dc-1, connID, connOpts.ConnectionProto)
 }
 
-func (t *DirectTelegram) Init(connOpts *mtproto.ConnectionOpts, conn wrappers.WrapStreamReadWriteCloser) (wrappers.Wrap, error) {
+func (t *DirectTelegram) Init(connOpts *mtproto.ConnectionOpts, conn wrappers.StreamReadWriteCloser) (wrappers.Wrap, error) {
 	obfs2, frame := obfuscated2.MakeTelegramObfuscated2Frame(connOpts)
 
 	if _, err := conn.Write(frame); err != nil {

telegram/middle.go

 	conf *config.Config
 }
 
-func (t *MiddleTelegram) Init(connOpts *mtproto.ConnectionOpts, conn wrappers.WrapStreamReadWriteCloser) (wrappers.Wrap, error) {
+func (t *MiddleTelegram) Init(connOpts *mtproto.ConnectionOpts, conn wrappers.StreamReadWriteCloser) (wrappers.Wrap, error) {
 	rpcNonceConn := wrappers.NewMTProtoFrame(conn, rpc.SeqNoNonce)
 
 	rpcNonceReq, err := t.sendRPCNonceRequest(rpcNonceConn)
 	return wrappers.NewMTProtoProxy(frameConn, connOpts, t.conf.AdTag)
 }
 
-func (t *MiddleTelegram) sendRPCNonceRequest(conn wrappers.WrapPacketWriter) (*rpc.NonceRequest, error) {
+func (t *MiddleTelegram) sendRPCNonceRequest(conn wrappers.PacketWriter) (*rpc.NonceRequest, error) {
 	rpcNonceReq, err := rpc.NewNonceRequest(t.proxySecret)
 	if err != nil {
 		return nil, errors.Annotate(err, "Cannot create RPC nonce request")
 	return rpcNonceReq, nil
 }
 
-func (t *MiddleTelegram) receiveRPCNonceResponse(conn wrappers.WrapPacketReader, req *rpc.NonceRequest) (*rpc.NonceResponse, error) {
+func (t *MiddleTelegram) receiveRPCNonceResponse(conn wrappers.PacketReader, req *rpc.NonceRequest) (*rpc.NonceResponse, error) {
 	packet, err := conn.Read()
 	if err != nil {
 		return nil, errors.Annotate(err, "Cannot read RPC nonce response")
 	return rpcNonceResp, nil
 }
 
-func (t *MiddleTelegram) sendRPCHandshakeRequest(conn wrappers.WrapPacketWriter) (*rpc.HandshakeRequest, error) {
+func (t *MiddleTelegram) sendRPCHandshakeRequest(conn wrappers.PacketWriter) (*rpc.HandshakeRequest, error) {
 	req := rpc.NewHandshakeRequest()
 	if _, err := conn.Write(req.Bytes()); err != nil {
 		return nil, errors.Annotate(err, "Cannot send RPC handshake request")
 	return req, nil
 }
 
-func (t *MiddleTelegram) receiveRPCHandshakeResponse(conn wrappers.WrapPacketReader, req *rpc.HandshakeRequest) (*rpc.HandshakeResponse, error) {
+func (t *MiddleTelegram) receiveRPCHandshakeResponse(conn wrappers.PacketReader, req *rpc.HandshakeRequest) (*rpc.HandshakeResponse, error) {
 	packet, err := conn.Read()
 	if err != nil {
 		return nil, errors.Annotate(err, "Cannot read RPC handshake response")

telegram/middle_caller.go

 	tgUserAgent       = "mtg"
 )
 
-var middleTelegramProxyConfigSplitter *regexp.Regexp
+var middleTelegramProxyConfigSplitter = regexp.MustCompile(`\s+`)
 
 type middleTelegramCaller struct {
 	baseTelegram
 	httpClient  *http.Client
 }
 
-func (t *middleTelegramCaller) Dial(connID string, connOpts *mtproto.ConnectionOpts) (wrappers.WrapStreamReadWriteCloser, error) {
+func (t *middleTelegramCaller) Dial(connID string, connOpts *mtproto.ConnectionOpts) (wrappers.StreamReadWriteCloser, error) {
 	dc := connOpts.DC
 	if dc == 0 {
 		dc = 1
 
 	return t.httpClient.Do(req)
 }
-
-func init() {
-	middleTelegramProxyConfigSplitter = regexp.MustCompile(`\s+`)
-}

telegram/telegram.go

 )
 
 type Telegram interface {
-	Dial(string, *mtproto.ConnectionOpts) (wrappers.WrapStreamReadWriteCloser, error)
-	Init(*mtproto.ConnectionOpts, wrappers.WrapStreamReadWriteCloser) (wrappers.Wrap, error)
+	Dial(string, *mtproto.ConnectionOpts) (wrappers.StreamReadWriteCloser, error)
+	Init(*mtproto.ConnectionOpts, wrappers.StreamReadWriteCloser) (wrappers.Wrap, error)
 }
 
 type baseTelegram struct {
 	v6Addresses map[int16][]string
 }
 
-func (b *baseTelegram) dial(dcIdx int16, connID string, proto mtproto.ConnectionProtocol) (wrappers.WrapStreamReadWriteCloser, error) {
+func (b *baseTelegram) dial(dcIdx int16, connID string, proto mtproto.ConnectionProtocol) (wrappers.StreamReadWriteCloser, error) {
 	addrs := make([]string, 2)
 
 	if proto&mtproto.ConnectionProtocolIPv6 != 0 {

wrappers/blockcipher.go

 type BlockCipher struct {
 	buf *bytes.Buffer
 
-	conn      WrapStreamReadWriteCloser
+	conn      StreamReadWriteCloser
 	encryptor cipher.BlockMode
 	decryptor cipher.BlockMode
 }
 	return b.conn.Close()
 }
 
-func NewBlockCipher(conn WrapStreamReadWriteCloser, encryptor, decryptor cipher.BlockMode) WrapStreamReadWriteCloser {
+func NewBlockCipher(conn StreamReadWriteCloser, encryptor, decryptor cipher.BlockMode) StreamReadWriteCloser {
 	return &BlockCipher{
 		buf:       &bytes.Buffer{},
 		conn:      conn,

wrappers/conn.go

 	c.logger.Errorw(msg, data...)
 }
 
-func NewConn(conn net.Conn, connID string, purpose ConnPurpose, publicIPv4, publicIPv6 net.IP) WrapStreamReadWriteCloser {
+func NewConn(conn net.Conn, connID string, purpose ConnPurpose, publicIPv4, publicIPv6 net.IP) StreamReadWriteCloser {
 	logger := zap.S().With(
 		"connection_id", connID,
 		"local_address", conn.LocalAddr(),

wrappers/ctx.go

 
 type Ctx struct {
 	cancel context.CancelFunc
-	conn   WrapStreamReadWriteCloser
+	conn   StreamReadWriteCloser
 	ctx    context.Context
 }
 
 	return c.conn.Close()
 }
 
-func NewCtx(ctx context.Context, cancel context.CancelFunc, conn WrapStreamReadWriteCloser) WrapStreamReadWriteCloser {
+func NewCtx(ctx context.Context, cancel context.CancelFunc, conn StreamReadWriteCloser) StreamReadWriteCloser {
 	return &Ctx{
 		ctx:    ctx,
 		cancel: cancel,

wrappers/mtproto_abridged.go

 )
 
 type MTProtoAbridged struct {
-	conn WrapStreamReadWriteCloser
+	conn StreamReadWriteCloser
 	opts *mtproto.ConnectionOpts
 
 	readCounter  uint32
 	return m.conn.Close()
 }
 
-func NewMTProtoAbridged(conn WrapStreamReadWriteCloser, opts *mtproto.ConnectionOpts) WrapPacketReadWriteCloser {
+func NewMTProtoAbridged(conn StreamReadWriteCloser, opts *mtproto.ConnectionOpts) PacketReadWriteCloser {
 	return &MTProtoAbridged{
 		conn: conn,
 		opts: opts,

wrappers/mtproto_cipher.go

 
 var emptyIP = [4]byte{0x00, 0x00, 0x00, 0x00}
 
-func NewMiddleProxyCipher(conn WrapStreamReadWriteCloser, req *rpc.NonceRequest, resp *rpc.NonceResponse, secret []byte) WrapStreamReadWriteCloser {
+func NewMiddleProxyCipher(conn StreamReadWriteCloser, req *rpc.NonceRequest, resp *rpc.NonceResponse, secret []byte) StreamReadWriteCloser {
 	localAddr := conn.LocalAddr()
 	remoteAddr := conn.RemoteAddr()
 

wrappers/mtproto_frame.go

 var mtprotoFramePadding = []byte{0x04, 0x00, 0x00, 0x00}
 
 type MTProtoFrame struct {
-	conn       WrapStreamReadWriteCloser
+	conn       StreamReadWriteCloser
 	readSeqNo  int32
 	writeSeqNo int32
 }
 	return m.conn.Close()
 }
 
-func NewMTProtoFrame(conn WrapStreamReadWriteCloser, seqNo int32) WrapPacketReadWriteCloser {
+func NewMTProtoFrame(conn StreamReadWriteCloser, seqNo int32) PacketReadWriteCloser {
 	return &MTProtoFrame{
 		conn:       conn,
 		readSeqNo:  seqNo,

wrappers/mtproto_intermediate.go

 const mtprotoIntermediateQuickAckLength = 0x80000000
 
 type MTProtoIntermediate struct {
-	conn WrapStreamReadWriteCloser
+	conn StreamReadWriteCloser
 	opts *mtproto.ConnectionOpts
 
 	readCounter  uint32
 	return m.conn.Close()
 }
 
-func NewMTProtoIntermediate(conn WrapStreamReadWriteCloser, opts *mtproto.ConnectionOpts) WrapPacketReadWriteCloser {
+func NewMTProtoIntermediate(conn StreamReadWriteCloser, opts *mtproto.ConnectionOpts) PacketReadWriteCloser {
 	return &MTProtoIntermediate{
 		conn: conn,
 		opts: opts,

wrappers/mtproto_proxy.go

 )
 
 type MTProtoProxy struct {
-	conn WrapPacketReadWriteCloser
+	conn PacketReadWriteCloser
 	req  *rpc.ProxyRequest
 
 	readCounter  uint32
 	return m.conn.Close()
 }
 
-func NewMTProtoProxy(conn WrapPacketReadWriteCloser, connOpts *mtproto.ConnectionOpts, adTag []byte) (WrapPacketReadWriteCloser, error) {
+func NewMTProtoProxy(conn PacketReadWriteCloser, connOpts *mtproto.ConnectionOpts, adTag []byte) (PacketReadWriteCloser, error) {
 	req, err := rpc.NewProxyRequest(connOpts.ClientAddr, conn.LocalAddr(), connOpts, adTag)
 	if err != nil {
 		return nil, errors.Annotate(err, "Cannot create new RPC proxy request")

wrappers/streamcipher.go

 type StreamCipher struct {
 	encryptor cipher.Stream
 	decryptor cipher.Stream
-	conn      WrapStreamReadWriteCloser
+	conn      StreamReadWriteCloser
 }
 
 func (s *StreamCipher) Read(p []byte) (int, error) {
 	return s.conn.Close()
 }
 
-func NewStreamCipher(conn WrapStreamReadWriteCloser, encryptor, decryptor cipher.Stream) WrapStreamReadWriteCloser {
+func NewStreamCipher(conn StreamReadWriteCloser, encryptor, decryptor cipher.Stream) StreamReadWriteCloser {
 	return &StreamCipher{
 		conn:      conn,
 		encryptor: encryptor,

wrappers/wrap.go

 	RemoteAddr() *net.TCPAddr
 }
 
-type WrapWriter interface {
+type Writer interface {
 	io.Writer
 	Wrap
 }
 
-type WrapCloser interface {
+type Closer interface {
 	io.Closer
 	Wrap
 }
 
-type WrapWriteCloser interface {
+type WriteCloser interface {
 	io.Closer
-	WrapWriter
+	Writer
 }
 
-type WrapStreamReader interface {
+type StreamReader interface {
 	io.Reader
 	Wrap
 }
 
-type WrapStreamReadCloser interface {
+type StreamReadCloser interface {
 	io.Closer
-	WrapStreamReader
+	StreamReader
 }
 
-type WrapStreamReadWriter interface {
+type StreamReadWriter interface {
 	io.Writer
-	WrapStreamReader
+	StreamReader
 }
 
-type WrapStreamWriteCloser interface {
+type StreamWriteCloser interface {
 	io.Closer
 	io.Writer
 	Wrap
 }
 
-type WrapStreamReadWriteCloser interface {
+type StreamReadWriteCloser interface {
 	io.Closer
-	WrapStreamReadWriter
+	StreamReadWriter
 }
 
-type WrapPacketReader interface {
+type PacketReader interface {
 	Read() ([]byte, error)
 	Wrap
 }
 
-type WrapPacketWriter interface {
+type PacketWriter interface {
 	io.Writer
 	Wrap
 }
 
-type WrapPacketReadWriter interface {
+type PacketReadWriter interface {
 	io.Writer
-	WrapPacketReader
+	PacketReader
 }
 
-type WrapBlockReadCloser interface {
+type BlockReadCloser interface {
 	io.Closer
-	WrapPacketReader
+	PacketReader
 }
 
-type WrapPacketWriteCloser interface {
+type PacketWriteCloser interface {
 	io.Writer
 	io.Closer
 	Wrap
 }
 
-type WrapPacketReadWriteCloser interface {
+type PacketReadWriteCloser interface {
 	io.Closer
-	WrapPacketReadWriter
+	PacketReadWriter
 }