Bump version to 0.7.2

Bump version to 0.7.2rc1
Only leave group chat portals with default puppet. Fixes #418
2020-04-04 22:05:01 +03:00 · 2020-02-08 13:32:25 +02:00 · 2020-02-08 13:28:07 +02:00 · 2020-02-08 13:28:07 +02:00
38 changed files with 356 additions and 919 deletions
@@ -13,6 +13,3 @@ max_line_length = 99

 [*.{yaml,yml,py}]
 indent_style = space
-
-[.gitlab-ci.yml]
-indent_size = 2
@@ -2,40 +2,37 @@ image: docker:stable

 stages:
 - build
- manifest
+- push

 default:
  before_script:
  - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY

-build amd64:
+build:
  stage: build
-  tags:
-  - amd64
  script:
  - docker pull $CI_REGISTRY_IMAGE:latest || true
-  - docker build --pull --cache-from $CI_REGISTRY_IMAGE:latest --tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 .
-  - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64
-  - docker rmi $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64
+  - docker build --pull --cache-from $CI_REGISTRY_IMAGE:latest --tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
+  - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

-build arm64:
-  stage: build
-  tags:
-  - arm64
+push latest:
+  stage: push
+  only:
+  - master
+  variables:
+    GIT_STRATEGY: none
  script:
-  - docker pull $CI_REGISTRY_IMAGE:latest || true
-  - docker build --pull --cache-from $CI_REGISTRY_IMAGE:latest --tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64 .
-  - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64
-  - docker rmi $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64
+  - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
+  - docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA $CI_REGISTRY_IMAGE:latest
+  - docker push $CI_REGISTRY_IMAGE:latest

-manifest:
-  stage: manifest
-  before_script:
-  - "mkdir -p $HOME/.docker && echo '{\"experimental\": \"enabled\"}' > $HOME/.docker/config.json"
-  - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+push tag:
+  stage: push
+  variables:
+    GIT_STRATEGY: none
+  except:
+  - master
  script:
-  - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64
-  - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64
-  - if [ "$CI_COMMIT_BRANCH" = "master" ]; then docker manifest create $CI_REGISTRY_IMAGE:latest $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64 && docker manifest push $CI_REGISTRY_IMAGE:latest; fi
-  - if [ "$CI_COMMIT_BRANCH" != "master" ]; then docker manifest create $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_NAME $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64 && docker manifest push $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_NAME; fi
-  - docker rmi $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64
+  - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
+  - docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_NAME
+  - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_NAME
@@ -1,21 +1,55 @@
-FROM dock.mau.dev/tulir/lottieconverter:alpine-3.11
+FROM docker.io/alpine:3.10 AS lottieconverter

-RUN echo "@edge_main http://dl-cdn.alpinelinux.org/alpine/edge/main" >> /etc/apk/repositories
-RUN echo "@edge_testing http://dl-cdn.alpinelinux.org/alpine/edge/testing" >> /etc/apk/repositories
-RUN echo "@edge_community http://dl-cdn.alpinelinux.org/alpine/edge/community" >> /etc/apk/repositories
+WORKDIR /build

-RUN apk add --no-cache \
+RUN apk add --no-cache git build-base cmake \
+  && git clone https://github.com/Samsung/rlottie.git \
+  && cd rlottie \
+  && mkdir build \
+  && cd build \
+  && cmake .. \
+  && make -j2 \
+  && make install \
+  && cd ../..
+
+RUN apk add --no-cache libpng libpng-dev zlib zlib-dev \
+  && git clone https://github.com/Eramde/LottieConverter.git \
+  && cd LottieConverter \
+  && git checkout 543c1d23ac9322f4f03c7fb6612ea7d026d44ac0 \
+  && make
+
+FROM docker.io/alpine:3.11
+
+ENV UID=1337 \
+    GID=1337 \
+    FFMPEG_BINARY=/usr/bin/ffmpeg
+
+COPY --from=lottieconverter /usr/lib/librlottie* /usr/lib/
+COPY --from=lottieconverter /build/LottieConverter/dist/Debug/GNU-Linux/lottieconverter /usr/local/bin/lottieconverter
+
+COPY . /opt/mautrix-telegram
+WORKDIR /opt/mautrix-telegram
+RUN apk add --no-cache --virtual .build-deps \
+      python3-dev \
+      libffi-dev \
+      build-base \
+      git \
+  && apk add --no-cache \
      py3-virtualenv \
      py3-pillow \
      py3-aiohttp \
      py3-magic \
      py3-sqlalchemy \
-      py3-alembic@edge_testing \
      py3-psycopg2 \
      py3-ruamel.yaml \
-      py3-commonmark@edge_testing \
      # Indirect dependencies
      py3-idna \
+      #commonmark
+        py3-future \
+      #alembic
+        py3-mako \
+        py3-dateutil \
+        py3-markupsafe \
      #moviepy
        py3-decorator \
        py3-tqdm \
@@ -24,50 +58,20 @@ RUN apk add --no-cache \
          py3-numpy \
      #telethon
        py3-rsa \
-        # Optional for socks proxies
-        py3-pysocks \
        # cryptg
          py3-cffi \
-      py3-brotli \
      # Other dependencies
      ffmpeg \
      ca-certificates \
      su-exec \
      netcat-openbsd \
-      # olm
-      olm-dev@edge_community \
-      # matrix-nio?
-      py3-future \
-      py3-atomicwrites \
-      py3-pycryptodome@edge_main \
-      py3-peewee@edge_community \
-      py3-pyrsistent@edge_community \
-      py3-jsonschema \
-      py3-aiofiles \
-      py3-cachetools@edge_community \
-      py3-prometheus-client@edge_community \
-      py3-unpaddedbase64 \
-      py3-pyaes@edge_testing \
-      py3-logbook@edge_testing
-
-COPY requirements.txt /opt/mautrix-telegram/requirements.txt
-COPY optional-requirements.txt /opt/mautrix-telegram/optional-requirements.txt
-WORKDIR /opt/mautrix-telegram
-RUN apk add --virtual .build-deps \
-      python3-dev \
-      libffi-dev \
-      build-base \
- && sed -Ei 's/psycopg2-binary.+//' optional-requirements.txt \
- && pip3 install -r requirements.txt -r optional-requirements.txt \
+      # lottieconverter
+      zlib libpng \
+ && pip3 install .[speedups,hq_thumbnails,metrics] \
+ # pip installs the sources to /usr/lib/python3.8/site-packages, so we don't need them here
+ && rm -rf /opt/mautrix-telegram/mautrix_telegram \
 && apk del .build-deps

-COPY . /opt/mautrix-telegram
-RUN apk add git && pip3 install .[speedups,hq_thumbnails,metrics,e2be] && apk del git \
-  # This doesn't make the image smaller, but it's needed so that the `version` command works properly
-  && cp mautrix_telegram/example-config.yaml . && rm -rf mautrix_telegram
-
 VOLUME /data
-ENV UID=1337 GID=1337 \
-    FFMPEG_BINARY=/usr/bin/ffmpeg

 CMD ["/opt/mautrix-telegram/docker-run.sh"]
@@ -1,4 +0,0 @@
-include README.md
-include LICENSE
-include requirements.txt
-include optional-requirements.txt
@@ -7,9 +7,6 @@

 A Matrix-Telegram hybrid puppeting/relaybot bridge.

-## Sponsors
-* [Joel Lehtonen / Zouppen](https://github.com/zouppen)
-
 ### [Wiki](https://github.com/tulir/mautrix-telegram/wiki)

 ### [Features & Roadmap](https://github.com/tulir/mautrix-telegram/blob/master/ROADMAP.md)
@@ -29,9 +29,6 @@
  * [x] Message deletions
  * [x] Message edits
  * [ ] Message history
-    * [x] Manually (`!tg backfill`)
-    * [ ] Automatically when creating portal
-    * [ ] Automatically for missed messages
  * [x] Avatars
  * [x] Presence
  * [x] Typing notifications
@@ -1,27 +0,0 @@
-"""Add encrypted field for portals
-
-Revision ID: 24f31fc8a72b
-Revises: a7c04a56041b
-Create Date: 2020-03-28 20:14:29.046699
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = "24f31fc8a72b"
-down_revision = "a7c04a56041b"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    with op.batch_alter_table("portal") as batch_op:
-        batch_op.add_column(sa.Column("encrypted", sa.Boolean(), nullable=False,
-                                      server_default=sa.sql.expression.false()))
-
-
-def downgrade():
-    with op.batch_alter_table("portal") as batch_op:
-        batch_op.drop_column("encrypted")
@@ -1,26 +0,0 @@
-"""Add decryption info field for reuploaded telegram files
-
-Revision ID: d3c922a6acd2
-Revises: 24f31fc8a72b
-Create Date: 2020-03-30 20:07:17.340346
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'd3c922a6acd2'
-down_revision = '24f31fc8a72b'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    with op.batch_alter_table("telegram_file") as batch_op:
-        batch_op.add_column(sa.Column("decryption_info", sa.Text(), nullable=True))
-
-
-def downgrade():
-    with op.batch_alter_table("telegram_file") as batch_op:
-        batch_op.drop_column("decryption_info")
@@ -1,71 +0,0 @@
-"""Add matrix-nio state store to main db
-
-Revision ID: dff56c93da8d
-Revises: d3c922a6acd2
-Create Date: 2020-03-31 22:04:04.014048
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'dff56c93da8d'
-down_revision = 'd3c922a6acd2'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('nio_account',
-    sa.Column('user_id', sa.String(length=255), nullable=False),
-    sa.Column('device_id', sa.String(length=255), nullable=False),
-    sa.Column('shared', sa.Boolean(), nullable=False),
-    sa.Column('sync_token', sa.Text(), nullable=False),
-    sa.Column('account', sa.LargeBinary(), nullable=False),
-    sa.PrimaryKeyConstraint('user_id', 'device_id')
-    )
-    op.create_table('nio_device_key',
-    sa.Column('user_id', sa.String(length=255), nullable=False),
-    sa.Column('device_id', sa.String(length=255), nullable=False),
-    sa.Column('display_name', sa.String(length=255), nullable=False),
-    sa.Column('deleted', sa.Boolean(), nullable=False),
-    sa.Column('keys', sa.PickleType(), nullable=False),
-    sa.PrimaryKeyConstraint('user_id', 'device_id')
-    )
-    op.create_table('nio_megolm_inbound_session',
-    sa.Column('session_id', sa.String(length=255), nullable=False),
-    sa.Column('sender_key', sa.String(length=255), nullable=False),
-    sa.Column('fp_key', sa.String(length=255), nullable=False),
-    sa.Column('room_id', sa.String(length=255), nullable=False),
-    sa.Column('session', sa.LargeBinary(), nullable=False),
-    sa.Column('forwarded_chains', sa.PickleType(), nullable=False),
-    sa.PrimaryKeyConstraint('session_id')
-    )
-    op.create_table('nio_olm_session',
-    sa.Column('session_id', sa.String(length=255), nullable=False),
-    sa.Column('sender_key', sa.String(length=255), nullable=False),
-    sa.Column('session', sa.LargeBinary(), nullable=False),
-    sa.Column('created_at', sa.DateTime(), nullable=False),
-    sa.Column('last_used', sa.DateTime(), nullable=False),
-    sa.PrimaryKeyConstraint('session_id')
-    )
-    op.create_table('nio_outgoing_key_request',
-    sa.Column('request_id', sa.String(length=255), nullable=False),
-    sa.Column('session_id', sa.String(length=255), nullable=False),
-    sa.Column('room_id', sa.String(length=255), nullable=False),
-    sa.Column('algorithm', sa.String(length=255), nullable=False),
-    sa.PrimaryKeyConstraint('request_id')
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('nio_outgoing_key_request')
-    op.drop_table('nio_olm_session')
-    op.drop_table('nio_megolm_inbound_session')
-    op.drop_table('nio_device_key')
-    op.drop_table('nio_account')
-    # ### end Alembic commands ###
@@ -13,6 +13,8 @@ sed -i "s#sqlite:///mautrix-telegram.db#sqlite:////data/mautrix-telegram.db#" /d
 if [ -f /data/mx-state.json ]; then
 	ln -s /data/mx-state.json
 fi
+# Check that database is in the right state
+alembic -x config=/data/config.yaml upgrade head

 if [ ! -f /data/config.yaml ]; then
 	cp example-config.yaml /data/config.yaml
@@ -33,8 +35,5 @@ if [ ! -f /data/registration.yaml ]; then
 	exit
 fi

-# Check that database is in the right state
-alembic -x config=/data/config.yaml upgrade head
-
 fixperms
 exec su-exec $UID:$GID python3 -m mautrix_telegram -c /data/config.yaml
@@ -13,9 +13,6 @@ homeserver:
 appservice:
    # The address that the homeserver can use to connect to this appservice.
    address: http://localhost:29317
-    # When using https:// the TLS certificate and key files for the address.
-    tls_cert: false
-    tls_key: false

    # The hostname and port where this appservice should listen.
    hostname: 0.0.0.0
@@ -65,8 +62,6 @@ appservice:

    # Community ID for bridged users (changes registration file) and rooms.
    # Must be created manually.
-    #
-    # Example: "+telegram:example.com". Set to false to disable.
    community_id: false

    # Authentication tokens for AS <-> HS communication. Autogenerated; do not modify.
@@ -121,10 +116,6 @@ bridge:
    - phone number
    # Maximum length of displayname
    displayname_max_length: 100
-    # Remove avatars from Telegram ghost users when removed on Telegram. This is disabled by default
-    # as there's no way to determine whether an avatar is removed or just hidden from some users. If
-    # you're on a single-user instance, this should be safe to enable.
-    allow_avatar_remove: false

    # Maximum number of members to sync per portal when starting up. Other members will be
    # synced when they send messages. The maximum is 10000, after which the Telegram server
@@ -200,25 +191,6 @@ bridge:
            height: 256
            background: "020202"  # only for gif
            fps: 30               # only for webm
-    # End-to-bridge encryption support options. These require matrix-nio to be installed with pip
-    # and login_shared_secret to be configured in order to get a device for the bridge bot.
-    #
-    # Additionally, https://github.com/matrix-org/synapse/pull/5758 is required if using a normal
-    # application service.
-    encryption:
-        # Allow encryption, work in group chat rooms with e2ee enabled
-        allow: false
-        # Default to encryption, force-enable encryption in all portals the bridge creates
-        # This will cause the bridge bot to be in private chats for the encryption to work properly.
-        default: false
-    # Whether or not to explicitly set the avatar and room name for private
-    # chat portal rooms. This will be implicitly enabled if encryption.default is true.
-    private_chat_portal_meta: false
-    # Whether or not the bridge should send a read receipt from the bridge bot when a message has
-    # been sent to Telegram.
-    delivery_receipts: false
-    # Whether or not delivery errors should be reported as messages in the Matrix room.
-    delivery_error_reports: false

    # Overrides for base power levels.
    initial_power_level_overrides:
@@ -437,7 +409,7 @@ logging:
        mau:
            level: DEBUG
        telethon:
-            level: INFO
+            level: DEBUG
        aiohttp:
            level: INFO
    root:
@@ -1,2 +1,2 @@
-__version__ = "0.8.0rc5"
+__version__ = "0.7.2"
 __author__ = "Tulir Asokan <tulir@maunium.net>"
@@ -44,7 +44,6 @@ except ImportError:


 class TelegramBridge(Bridge):
-    module = "mautrix_telegram"
    name = "mautrix-telegram"
    command = "python -m mautrix-telegram"
    description = "A Matrix-Telegram puppeting bridge."
@@ -35,7 +35,6 @@ from telethon.tl.types import (
 from mautrix.types import UserID, PresenceState
 from mautrix.errors import MatrixError
 from mautrix.appservice import AppService
-from mautrix.util.logging import TraceLogger
 from alchemysession import AlchemySessionContainer

 from . import portal as po, puppet as pu, __version__
@@ -69,7 +68,7 @@ except ImportError:
 class AbstractUser(ABC):
    session_container: AlchemySessionContainer = None
    loop: asyncio.AbstractEventLoop = None
-    log: TraceLogger
+    log: logging.Logger
    az: AppService
    relaybot: Optional['Bot']
    ignore_incoming_bot_events: bool = True
@@ -259,7 +258,7 @@ class AbstractUser(ABC):
        elif isinstance(update, UpdateReadHistoryOutbox):
            await self.update_read_receipt(update)
        else:
-            self.log.trace("Unhandled update: %s", update)
+            self.log.debug("Unhandled update: %s", update)

    async def update_pinned_messages(self, update: Union[UpdateChannelPinnedMessage,
                                                         UpdateChatPinnedMessage]) -> None:
@@ -334,7 +333,7 @@ class AbstractUser(ABC):
            if await puppet.update_avatar(self, update.photo):
                puppet.save()
        else:
-            self.log.warning(f"Unexpected other user info update: {type(update)}")
+            self.log.warning("Unexpected other user info update: %s", update)

    async def update_status(self, update: UpdateUserStatus) -> None:
        puppet = pu.Puppet.get(TelegramID(update.user_id))
@@ -343,7 +342,7 @@ class AbstractUser(ABC):
        elif isinstance(update.status, UserStatusOffline):
            await puppet.default_mxid_intent.set_presence(PresenceState.OFFLINE)
        else:
-            self.log.warning(f"Unexpected user status update: type({update})")
+            self.log.warning("Unexpected user status update: %s", update)
        return

    def get_message_details(self, update: UpdateMessage) -> Tuple[UpdateMessageContent,
@@ -367,7 +366,8 @@ class AbstractUser(ABC):
                portal = po.Portal.get_by_entity(update.to_id, receiver_id=self.tgid)
            sender = pu.Puppet.get(update.from_id) if update.from_id else None
        else:
-            self.log.warning(f"Unexpected message type in User#get_message_details: {type(update)}")
+            self.log.warning(
+                f"Unexpected message type in User#get_message_details: {type(update)}")
            return update, None, None
        return update, sender, portal

@@ -428,10 +428,11 @@ class AbstractUser(ABC):

        if isinstance(update, MessageService):
            if isinstance(update.action, MessageActionChannelMigrateFrom):
-                self.log.trace(f"Ignoring action %s to %s by %d", update.action, portal.tgid_log,
+                self.log.debug(f"Ignoring action %s to %s by %d", update.action,
+                               portal.tgid_log,
                               sender.id)
                return
-            self.log.trace("Handling action %s to %s by %d", update.action, portal.tgid_log,
+            self.log.debug("Handling action %s to %s by %d", update.action, portal.tgid_log,
                           sender.id)
            return await portal.handle_telegram_action(self, sender, update)

@@ -147,7 +147,7 @@ class Bot(AbstractUser):
        if self.whitelist_group_admins:
            if isinstance(chat, PeerChannel):
                p = await self.client(GetParticipantRequest(chat, tgid))
-                return isinstance(p.participant, (ChannelParticipantCreator, ChannelParticipantAdmin))
+                return isinstance(p, (ChannelParticipantCreator, ChannelParticipantAdmin))
            elif isinstance(chat, PeerChat):
                chat = await self.client(GetFullChatRequest(chat.chat_id))
                participants = chat.full_chat.participants.participants
@@ -25,10 +25,10 @@ from .util import user_has_power_level, get_initial_state
                 help_args="[_type_]",
                 help_text="Create a Telegram chat of the given type for the current Matrix room. "
                           "The type is either `group`, `supergroup` or `channel` (defaults to "
-                           "`supergroup`).")
+                           "`group`).")
 async def create(evt: CommandEvent) -> EventID:
-    type = evt.args[0] if len(evt.args) > 0 else "supergroup"
-    if type not in ("chat", "group", "supergroup", "channel"):
+    type = evt.args[0] if len(evt.args) > 0 else "group"
+    if type not in {"chat", "group", "supergroup", "channel"}:
        return await evt.reply(
            "**Usage:** `$cmdprefix+sp create ['group'/'supergroup'/'channel']`")

@@ -22,7 +22,9 @@ from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT
 from .util import user_has_power_level


-async def _get_portal_and_check_permission(evt: CommandEvent) -> Optional[po.Portal]:
+async def _get_portal_and_check_permission(evt: CommandEvent, permission: str,
+                                           action: Optional[str] = None
+                                           ) -> Optional[po.Portal]:
    room_id = RoomID(evt.args[0]) if len(evt.args) > 0 else evt.room_id

    portal = po.Portal.get_by_mxid(room_id)
@@ -31,8 +33,9 @@ async def _get_portal_and_check_permission(evt: CommandEvent) -> Optional[po.Por
        await evt.reply(f"{that_this} is not a portal room.")
        return None

-    if not await user_has_power_level(portal.mxid, evt.az.intent, evt.sender, "unbridge"):
-        await evt.reply("You do not have the permissions to unbridge that portal.")
+    if not await user_has_power_level(portal.mxid, evt.az.intent, evt.sender, permission):
+        action = action or f"{permission.replace('_', ' ')}s"
+        await evt.reply(f"You do not have the permissions to {action} that portal.")
        return None
    return portal

@@ -61,7 +64,7 @@ def _get_portal_murder_function(action: str, room_id: str, function: Callable, c
                           "Only works for group chats; to delete a private chat portal, simply "
                           "leave the room.")
 async def delete_portal(evt: CommandEvent) -> Optional[EventID]:
-    portal = await _get_portal_and_check_permission(evt)
+    portal = await _get_portal_and_check_permission(evt, "unbridge")
    if not portal:
        return None

@@ -82,7 +85,7 @@ async def delete_portal(evt: CommandEvent) -> Optional[EventID]:
                 help_section=SECTION_PORTAL_MANAGEMENT,
                 help_text="Remove puppets from the current portal room and forget the portal.")
 async def unbridge(evt: CommandEvent) -> Optional[EventID]:
-    portal = await _get_portal_and_check_permission(evt)
+    portal = await _get_portal_and_check_permission(evt, "unbridge")
    if not portal:
        return None

@@ -20,11 +20,10 @@ import base64
 import re

 from telethon.errors import (InviteHashInvalidError, InviteHashExpiredError, OptionsTooMuchError,
-                             UserAlreadyParticipantError, ChatIdInvalidError,
-                             TakeoutInitDelayError, EmoticonInvalidError)
+                             UserAlreadyParticipantError, ChatIdInvalidError)
 from telethon.tl.patched import Message
 from telethon.tl.types import (User as TLUser, TypeUpdates, MessageMediaGame, MessageMediaPoll,
-                               TypeInputPeer, InputMediaDice)
+                               TypeInputPeer)
 from telethon.tl.types.messages import BotCallbackAnswer
 from telethon.tl.functions.messages import (ImportChatInviteRequest, CheckChatInviteRequest,
                                            GetBotCallbackAnswerRequest, SendVoteRequest)
@@ -36,8 +35,7 @@ from ... import puppet as pu, portal as po
 from ...abstract_user import AbstractUser
 from ...db import Message as DBMessage
 from ...types import TelegramID
-from ...commands import (command_handler, CommandEvent, SECTION_MISC, SECTION_CREATING_PORTALS,
-                         SECTION_PORTAL_MANAGEMENT)
+from ...commands import command_handler, CommandEvent, SECTION_MISC, SECTION_CREATING_PORTALS


@command_handler(needs_auth=False,
@@ -104,8 +102,7 @@ async def pm(evt: CommandEvent) -> EventID:
        return await evt.reply("**Usage:** `$cmdprefix+sp pm <user identifier>`")

    try:
-        id = "".join(evt.args).translate({ord(c): None for c in "+()- "})
-        user = await evt.sender.client.get_entity(id)
+        user = await evt.sender.client.get_entity(evt.args[0])
    except ValueError:
        return await evt.reply("Invalid user identifier or user not found.")

@@ -165,9 +162,7 @@ async def join(evt: CommandEvent) -> Optional[EventID]:
            try:
                await portal.create_matrix_room(evt.sender, chat, [evt.sender.mxid])
            except ChatIdInvalidError as e:
-                logging.getLogger("mau.commands").trace("ChatIdInvalidError while creating portal "
-                                                        "from !tg join command: %s",
-                                                        updates.stringify())
+                logging.getLogger("mau.commands").info(updates.stringify())
                raise e
            return await evt.reply(f"Created room for {portal.title}")
    return None
@@ -308,41 +303,3 @@ async def vote(evt: CommandEvent) -> EventID:
        return await evt.reply("You passed too many options.")
    # TODO use response
    return await evt.mark_read()
-
-
-@command_handler(help_section=SECTION_MISC, help_args="<_emoji_>",
-                 help_text="Roll a dice (\U0001F3B2) or throw a dart (\U0001F3AF) "
-                           "on the Telegram servers.")
-async def random(evt: CommandEvent) -> EventID:
-    if not evt.is_portal:
-        return await evt.reply("You can only roll dice in portal rooms")
-    portal = po.Portal.get_by_mxid(evt.room_id)
-    arg = evt.args[0] if len(evt.args) > 0 else "dice"
-    emoticon = {
-        "dart": "\U0001F3AF",
-        "dice": "\U0001F3B2",
-    }.get(arg, arg)
-    try:
-        await evt.sender.client.send_media(await portal.get_input_entity(evt.sender),
-                                           InputMediaDice(emoticon))
-    except EmoticonInvalidError:
-        return await evt.reply("Invalid emoji for randomization")
-
-
-@command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
-                 help_text="Backfill messages from Telegram history.")
-async def backfill(evt: CommandEvent) -> None:
-    if not evt.is_portal:
-        await evt.reply("You can only use backfill in portal rooms")
-        return
-    portal = po.Portal.get_by_mxid(evt.room_id)
-    try:
-        await portal.backfill(evt.sender)
-    except TakeoutInitDelayError:
-        msg = ("Please accept the data export request from a mobile device, "
-               "then re-run the backfill command.")
-        if portal.peer_type == "user":
-            from mautrix.appservice import IntentAPI
-            await portal.main_intent.send_notice(evt.room_id, msg)
-        else:
-            await evt.reply(msg)
@@ -45,18 +45,23 @@ class Config(BaseBridgeConfig):
        ]

    def do_update(self, helper: ConfigUpdateHelper) -> None:
-        super().do_update(helper)
        copy, copy_dict, base = helper

+        copy("homeserver.address")
+        copy("homeserver.domain")
+        copy("homeserver.verify_ssl")
+
        if "appservice.protocol" in self and "appservice.address" not in self:
            protocol, hostname, port = (self["appservice.protocol"], self["appservice.hostname"],
                                        self["appservice.port"])
            base["appservice.address"] = f"{protocol}://{hostname}:{port}"
-        if "appservice.debug" in self and "logging" not in self:
-            level = "DEBUG" if self["appservice.debug"] else "INFO"
-            base["logging.root.level"] = level
-            base["logging.loggers.mau.level"] = level
-            base["logging.loggers.telethon.level"] = level
+        else:
+            copy("appservice.address")
+        copy("appservice.hostname")
+        copy("appservice.port")
+        copy("appservice.max_body_size")
+
+        copy("appservice.database")

        copy("appservice.public.enabled")
        copy("appservice.public.prefix")
@@ -68,8 +73,16 @@ class Config(BaseBridgeConfig):
        if base["appservice.provisioning.shared_secret"] == "generate":
            base["appservice.provisioning.shared_secret"] = self._new_token()

+        copy("appservice.id")
+        copy("appservice.bot_username")
+        copy("appservice.bot_displayname")
+        copy("appservice.bot_avatar")
+
        copy("appservice.community_id")

+        copy("appservice.as_token")
+        copy("appservice.hs_token")
+
        copy("metrics.enabled")
        copy("metrics.listen_port")

@@ -83,7 +96,6 @@ class Config(BaseBridgeConfig):

        copy("bridge.displayname_preference")
        copy("bridge.displayname_max_length")
-        copy("bridge.allow_avatar_remove")

        copy("bridge.max_initial_member_sync")
        copy("bridge.sync_channel_members")
@@ -106,11 +118,6 @@ class Config(BaseBridgeConfig):
        copy("bridge.federate_rooms")
        copy("bridge.animated_sticker.target")
        copy("bridge.animated_sticker.args")
-        copy("bridge.encryption.allow")
-        copy("bridge.encryption.default")
-        copy("bridge.private_chat_portal_meta")
-        copy("bridge.delivery_receipts")
-        copy("bridge.delivery_error_reports")

        copy("bridge.initial_power_level_overrides.group")
        copy("bridge.initial_power_level_overrides.user")
@@ -195,6 +202,14 @@ class Config(BaseBridgeConfig):
        copy("telegram.proxy.username")
        copy("telegram.proxy.password")

+        if "appservice.debug" in self and "logging" not in self:
+            level = "DEBUG" if self["appservice.debug"] else "INFO"
+            base["logging.root.level"] = level
+            base["logging.loggers.mau.level"] = level
+            base["logging.loggers.telethon.level"] = level
+        else:
+            copy("logging")
+
    def _get_permissions(self, key: str) -> Permissions:
        level = self["bridge.permissions"].get(key, "")
        admin = level == "admin"
@@ -24,11 +24,6 @@ from .puppet import Puppet
 from .telegram_file import TelegramFile
 from .user import User, UserPortal, Contact

-try:
-    from mautrix.bridge.db.nio_state_store import init as init_nio_db
-except ImportError:
-    init_nio_db = None
-

 def init(db_engine: Engine) -> None:
    for table in (Portal, Message, User, Contact, UserPortal, Puppet, TelegramFile, UserProfile,
@@ -37,5 +32,3 @@ def init(db_engine: Engine) -> None:
        table.t = table.__table__
        table.c = table.t.c
        table.column_names = table.c.keys()
-    if init_nio_db:
-        init_nio_db(db_engine)
@@ -61,16 +61,6 @@ class Message(Base):
        except StopIteration:
            return 0

-    @classmethod
-    def find_last(cls, mx_room: RoomID, tg_space: TelegramID) -> Optional['Message']:
-        return cls._one_or_none(cls.db.execute(
-            cls._make_simple_select(cls.c.mx_room == mx_room, cls.c.tg_space == tg_space)
-                .order_by(desc(cls.c.tgid)).limit(1)))
-
-    @classmethod
-    def delete_all(cls, mx_room: RoomID) -> None:
-        cls.db.execute(cls.t.delete().where(cls.c.mx_room == mx_room))
-
    @classmethod
    def get_by_mxid(cls, mxid: EventID, mx_room: RoomID, tg_space: TelegramID
                    ) -> Optional['Message']:
@@ -15,7 +15,7 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from typing import Optional

-from sqlalchemy import Column, Integer, String, Boolean, Text, func, sql
+from sqlalchemy import Column, Integer, String, Boolean, Text, func

 from mautrix.types import RoomID
 from mautrix.util.db import Base
@@ -34,7 +34,6 @@ class Portal(Base):

    # Matrix portal information
    mxid: RoomID = Column(String, unique=True, nullable=True)
-    encrypted: bool = Column(Boolean, nullable=False, server_default=sql.expression.false())

    config: str = Column(Text, nullable=True)

@@ -13,37 +13,15 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Optional, cast, Dict, Any
+from typing import Optional

-from sqlalchemy import (Column, ForeignKey, Integer, BigInteger, String, Boolean, Text,
-                        TypeDecorator)
+from sqlalchemy import Column, ForeignKey, Integer, BigInteger, String, Boolean
 from sqlalchemy.engine.result import RowProxy

-from mautrix.types import ContentURI, EncryptedFile
+from mautrix.types import ContentURI
 from mautrix.util.db import Base


-class DBEncryptedFile(TypeDecorator):
-    impl = Text
-
-    @property
-    def python_type(self):
-        return EncryptedFile
-
-    def process_bind_param(self, value: EncryptedFile, dialect) -> Optional[str]:
-        if value is not None:
-            return value.json()
-        return None
-
-    def process_result_value(self, value: str, dialect) -> Optional[EncryptedFile]:
-        if value is not None:
-            return EncryptedFile.parse_json(value)
-        return None
-
-    def process_literal_param(self, value, dialect):
-        return value
-
-
 class TelegramFile(Base):
    __tablename__ = "telegram_file"

@@ -55,13 +33,12 @@ class TelegramFile(Base):
    size: Optional[int] = Column(Integer, nullable=True)
    width: Optional[int] = Column(Integer, nullable=True)
    height: Optional[int] = Column(Integer, nullable=True)
-    decryption_info: Optional[Dict[str, Any]] = Column(DBEncryptedFile, nullable=True)
    thumbnail_id: str = Column("thumbnail", String, ForeignKey("telegram_file.id"), nullable=True)
    thumbnail: Optional['TelegramFile'] = None

    @classmethod
    def scan(cls, row: RowProxy) -> 'TelegramFile':
-        telegram_file = cast(TelegramFile, super().scan(row))
+        telegram_file: TelegramFile = super().scan(row)
        if isinstance(telegram_file.thumbnail, str):
            telegram_file.thumbnail = cls.get(telegram_file.thumbnail)
        return telegram_file
@@ -75,5 +52,5 @@ class TelegramFile(Base):
            conn.execute(self.t.insert().values(
                id=self.id, mxc=self.mxc, mime_type=self.mime_type,
                was_converted=self.was_converted, timestamp=self.timestamp, size=self.size,
-                width=self.width, height=self.height, decryption_info=self.decryption_info,
+                width=self.width, height=self.height,
                thumbnail=self.thumbnail.id if self.thumbnail else self.thumbnail_id))
@@ -13,15 +13,14 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Set, Tuple, Union, Iterable, List, TYPE_CHECKING
+from typing import Dict, Set, Tuple, Union, Iterable, TYPE_CHECKING

 from mautrix.bridge import BaseMatrixHandler
 from mautrix.types import (Event, EventType, RoomID, UserID, EventID, ReceiptEvent, ReceiptType,
                           ReceiptEventContent, PresenceEvent, PresenceState, TypingEvent,
                           MessageEvent, StateEvent, RedactionEvent, RoomNameStateEventContent,
                           RoomAvatarStateEventContent, RoomTopicStateEventContent,
-                           MemberStateEventContent, EncryptedEvent, TextMessageEventContent,
-                           MessageType)
+                           MemberStateEventContent)
 from mautrix.errors import MatrixError

 from . import user as u, portal as po, puppet as pu, commands as com
@@ -48,15 +47,8 @@ class MatrixHandler(BaseMatrixHandler):
    previously_typing: Dict[RoomID, Set[UserID]]

    def __init__(self, context: 'Context') -> None:
-        prefix, suffix = context.config["bridge.username_template"].format(userid=":").split(":")
-        homeserver = context.config["homeserver.domain"]
-        self.user_id_prefix = f"@{prefix}"
-        self.user_id_suffix = f"{suffix}:{homeserver}"
-
        super(MatrixHandler, self).__init__(context.az, context.config, loop=context.loop,
-                                            command_processor=com.CommandProcessor(context),
-                                            bridge=context.bridge)
-
+                                            command_processor=com.CommandProcessor(context))
        self.bot = context.bot
        self.previously_typing = {}

@@ -112,38 +104,14 @@ class MatrixHandler(BaseMatrixHandler):
                except MatrixError:
                    pass
            portal.mxid = room_id
-            e2be_ok = None
-            if self.config["bridge.encryption.default"] and self.e2ee:
-                e2be_ok = await self.enable_dm_encryption(portal, members=members)
            portal.save()
            inviter.register_portal(portal)
-            if e2be_ok is True:
-                evt_type, content = await self.e2ee.encrypt(
-                    room_id, EventType.ROOM_MESSAGE,
-                    TextMessageEventContent(msgtype=MessageType.NOTICE,
-                                            body="Portal to private chat created and end-to-bridge"
-                                                 " encryption enabled."))
-                await intent.send_message_event(room_id, evt_type, content)
-            else:
-                message = "Portal to private chat created."
-                if e2be_ok is False:
-                    message += "\n\nWarning: Failed to enable end-to-bridge encryption"
-                await intent.send_notice(room_id, message)
+            await intent.send_notice(room_id, "Portal to private chat created.")
        else:
            await intent.join_room(room_id)
            await intent.send_notice(room_id, "This puppet will remain inactive until a "
                                              "Telegram chat is created for this room.")

-    async def enable_dm_encryption(self, portal: po.Portal, members: List[UserID]) -> bool:
-        ok = await super().enable_dm_encryption(portal, members)
-        if ok:
-            try:
-                puppet = pu.Puppet.get(portal.tgid)
-                await portal.main_intent.set_room_name(portal.mxid, puppet.displayname)
-            except Exception:
-                self.log.warning(f"Failed to set room name for {portal.mxid}", exc_info=True)
-        return ok
-
    async def send_welcome_message(self, room_id: RoomID, inviter: 'u.User') -> None:
        try:
            is_management = len(await self.az.intent.get_room_members(room_id)) == 2
@@ -188,7 +156,7 @@ class MatrixHandler(BaseMatrixHandler):
                                               "messages for unauthenticated users.")
            return

-        self.log.debug(f"{user.mxid} joined {room_id}")
+        self.log.debug(f"{user} joined {room_id}")
        if await user.is_logged_in() or portal.has_bot:
            await portal.join_matrix(user, event_id)

@@ -278,7 +246,7 @@ class MatrixHandler(BaseMatrixHandler):
        if not portal:
            return

-        await portal.handle_matrix_deletion(sender, evt.redacts, evt.event_id)
+        await portal.handle_matrix_deletion(sender, evt.redacts)

    @staticmethod
    async def handle_power_levels(evt: StateEvent) -> None:
@@ -286,12 +254,11 @@ class MatrixHandler(BaseMatrixHandler):
        sender = await u.User.get_by_mxid(evt.sender).ensure_started()
        if await sender.has_full_access(allow_bot=True) and portal:
            await portal.handle_matrix_power_levels(sender, evt.content.users,
-                                                    evt.unsigned.prev_content.users,
-                                                    evt.event_id)
+                                                    evt.unsigned.prev_content.users)

    @staticmethod
    async def handle_room_meta(evt_type: EventType, room_id: RoomID, sender_mxid: UserID,
-                               content: RoomMetaStateEventContent, event_id: EventID) -> None:
+                               content: RoomMetaStateEventContent) -> None:
        portal = po.Portal.get_by_mxid(room_id)
        sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
        if await sender.has_full_access(allow_bot=True) and portal:
@@ -302,29 +269,27 @@ class MatrixHandler(BaseMatrixHandler):
            }[evt_type]
            if not isinstance(content, content_type):
                return
-            await handler(sender, content[content_key], event_id)
+            await handler(sender, content[content_key])

    @staticmethod
    async def handle_room_pin(room_id: RoomID, sender_mxid: UserID,
-                              new_events: Set[str], old_events: Set[str],
-                              event_id: EventID) -> None:
+                              new_events: Set[str], old_events: Set[str]) -> None:
        portal = po.Portal.get_by_mxid(room_id)
        sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
        if await sender.has_full_access(allow_bot=True) and portal:
            events = new_events - old_events
            if len(events) > 0:
                # New event pinned, set that as pinned in Telegram.
-                await portal.handle_matrix_pin(sender, EventID(events.pop()), event_id)
+                await portal.handle_matrix_pin(sender, EventID(events.pop()))
            elif len(new_events) == 0:
                # All pinned events removed, remove pinned event in Telegram.
-                await portal.handle_matrix_pin(sender, None, event_id)
+                await portal.handle_matrix_pin(sender, None)

    @staticmethod
-    async def handle_room_upgrade(room_id: RoomID, sender: UserID, new_room_id: RoomID,
-                                  event_id: EventID) -> None:
+    async def handle_room_upgrade(room_id: RoomID, sender: UserID, new_room_id: RoomID) -> None:
        portal = po.Portal.get_by_mxid(room_id)
        if portal:
-            await portal.handle_matrix_upgrade(sender, new_room_id, event_id)
+            await portal.handle_matrix_upgrade(sender, new_room_id)

    async def handle_member_info_change(self, room_id: RoomID, user_id: UserID,
                                        profile: MemberStateEventContent,
@@ -390,13 +355,8 @@ class MatrixHandler(BaseMatrixHandler):
        self.previously_typing[room_id] = now_typing

    def filter_matrix_event(self, evt: Event) -> bool:
-        if not isinstance(evt, (RedactionEvent, MessageEvent, StateEvent, EncryptedEvent)):
+        if not isinstance(evt, (RedactionEvent, MessageEvent, StateEvent)):
            return True
-        if evt.content.get("net.maunium.telegram.puppet", False):
-            puppet = pu.Puppet.get_by_custom_mxid(evt.sender)
-            if puppet:
-                self.log.debug("Ignoring puppet-sent event %s", evt.event_id)
-                return True
        return evt.sender and (evt.sender == self.az.bot_mxid
                               or pu.Puppet.get_id_from_mxid(evt.sender) is not None)

@@ -417,24 +377,16 @@ class MatrixHandler(BaseMatrixHandler):
        if evt.type == EventType.ROOM_POWER_LEVELS:
            await self.handle_power_levels(evt)
        elif evt.type in (EventType.ROOM_NAME, EventType.ROOM_AVATAR, EventType.ROOM_TOPIC):
-            await self.handle_room_meta(evt.type, evt.room_id, evt.sender, evt.content,
-                                        evt.event_id)
+            await self.handle_room_meta(evt.type, evt.room_id, evt.sender, evt.content)
        elif evt.type == EventType.ROOM_PINNED_EVENTS:
            new_events = set(evt.content.pinned)
            try:
                old_events = set(evt.unsigned.prev_content.pinned)
            except (KeyError, ValueError, TypeError, AttributeError):
                old_events = set()
-            await self.handle_room_pin(evt.room_id, evt.sender, new_events, old_events,
-                                       evt.event_id)
+            await self.handle_room_pin(evt.room_id, evt.sender, new_events, old_events)
        elif evt.type == EventType.ROOM_TOMBSTONE:
-            await self.handle_room_upgrade(evt.room_id, evt.sender, evt.content.replacement_room,
-                                           evt.event_id)
-        elif evt.type == EventType.ROOM_ENCRYPTION:
-            portal = po.Portal.get_by_mxid(evt.room_id)
-            if portal:
-                portal.encrypted = True
-                portal.save()
+            await self.handle_room_upgrade(evt.room_id, evt.sender, evt.content.replacement_room)

    async def log_event_handle_duration(self, evt: Event, duration: float) -> None:
        if EVENT_TIME:
@@ -1,8 +1,8 @@
 from typing import Union
 from .base import BasePortal
-from .matrix import PortalMatrix
-from .metadata import PortalMetadata
-from .telegram import PortalTelegram
+from .portal_matrix import PortalMatrix
+from .portal_metadata import PortalMetadata
+from .portal_telegram import PortalTelegram
 from ..context import Context

 Portal = Union[BasePortal, PortalMatrix, PortalMetadata, PortalTelegram]
@@ -1,5 +1,5 @@
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2020 Tulir Asokan
+# Copyright (C) 2019 Tulir Asokan
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -13,7 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Awaitable, Dict, List, Optional, Tuple, Union, Any, Set, TYPE_CHECKING
+from typing import Awaitable, Dict, List, Optional, Tuple, Union, Any, TYPE_CHECKING
 from abc import ABC, abstractmethod
 import asyncio
 import logging
@@ -30,14 +30,12 @@ from telethon.tl.types import (Channel, ChannelFull, Chat, ChatFull, ChatInviteE

 from mautrix.errors import MatrixRequestError, IntentError
 from mautrix.appservice import AppService, IntentAPI
-from mautrix.types import (RoomID, RoomAlias, UserID, EventID, EventType, MessageEventContent,
-                           PowerLevelStateEventContent)
+from mautrix.types import RoomID, RoomAlias, UserID, EventType, PowerLevelStateEventContent
 from mautrix.util.simple_template import SimpleTemplate
-from mautrix.util.logging import TraceLogger

 from ..types import TelegramID
 from ..context import Context
-from ..db import Portal as DBPortal, Message as DBMessage
+from ..db import Portal as DBPortal
 from .. import puppet as p, user as u, util
 from .deduplication import PortalDedup
 from .send_lock import PortalSendLock
@@ -46,7 +44,6 @@ if TYPE_CHECKING:
    from ..bot import Bot
    from ..abstract_user import AbstractUser
    from ..config import Config
-    from ..matrix import MatrixHandler
    from . import Portal

 TypeParticipant = Union[TypeChatParticipant, TypeChannelParticipant]
@@ -57,11 +54,10 @@ config: Optional['Config'] = None


 class BasePortal(ABC):
-    base_log: TraceLogger = logging.getLogger("mau.portal")
+    base_log: logging.Logger = logging.getLogger("mau.portal")
    az: AppService = None
    bot: 'Bot' = None
    loop: asyncio.AbstractEventLoop = None
-    matrix: 'MatrixHandler' = None

    # Config cache
    filter_mode: str = None
@@ -71,7 +67,6 @@ class BasePortal(ABC):
    sync_channel_members: bool = True
    sync_matrix_state: bool = True
    public_portals: bool = False
-    private_chat_portal_meta: bool = False

    alias_template: SimpleTemplate[str]
    hs_domain: str
@@ -90,11 +85,8 @@ class BasePortal(ABC):
    about: Optional[str]
    photo_id: Optional[str]
    local_config: Dict[str, Any]
-    encrypted: bool
    deleted: bool
-    backfilling: bool
-    backfill_leave: Optional[Set[IntentAPI]]
-    log: TraceLogger
+    log: logging.Logger

    alias: Optional[RoomAlias]

@@ -108,8 +100,7 @@ class BasePortal(ABC):
                 mxid: Optional[RoomID] = None, username: Optional[str] = None,
                 megagroup: Optional[bool] = False, title: Optional[str] = None,
                 about: Optional[str] = None, photo_id: Optional[str] = None,
-                 local_config: Optional[str] = None, encrypted: Optional[bool] = False,
-                 db_instance: DBPortal = None) -> None:
+                 local_config: Optional[str] = None, db_instance: DBPortal = None) -> None:
        self.mxid = mxid
        self.tgid = tgid
        self.tg_receiver = tg_receiver or tgid
@@ -120,13 +111,10 @@ class BasePortal(ABC):
        self.about = about
        self.photo_id = photo_id
        self.local_config = json.loads(local_config or "{}")
-        self.encrypted = encrypted
        self._db_instance = db_instance
        self._main_intent = None
        self.deleted = False
        self.log = self.base_log.getChild(self.tgid_log if self.tgid else self.mxid)
-        self.backfilling = False
-        self.backfill_leave = None

        self.dedup = PortalDedup(self)
        self.send_lock = PortalSendLock()
@@ -136,7 +124,7 @@ class BasePortal(ABC):
        if mxid:
            self.by_mxid[mxid] = self

-    # region Properties
+    # region Propegrties

    @property
    def tgid_full(self) -> Tuple[TelegramID, TelegramID]:
@@ -245,7 +233,8 @@ class BasePortal(ABC):
            return await user.client.get_entity(self.peer)
        except ValueError:
            if user.is_bot:
-                self.log.warning(f"Could not find entity with bot {user.tgid}. Failing...")
+                self.log.warning(f"Could not find entity with bot {user.tgid}. "
+                                 "Failing...")
                raise
            self.log.warning(f"Could not find entity with user {user.tgid}. "
                             "falling back to get_dialogs.")
@@ -284,8 +273,8 @@ class BasePortal(ABC):
                authenticated.append(user)
        return authenticated

-    @classmethod
-    async def cleanup_room(cls, intent: IntentAPI, room_id: RoomID, message: str,
+    @staticmethod
+    async def cleanup_room(intent: IntentAPI, room_id: RoomID, message: str,
                           puppets_only: bool = False) -> None:
        try:
            members = await intent.get_room_members(room_id)
@@ -304,7 +293,7 @@ class BasePortal(ABC):
        try:
            await intent.leave_room(room_id)
        except (MatrixRequestError, IntentError):
-            cls.log.warning(f"Failed to leave room {room_id} when cleaning up room", exc_info=True)
+            self.log.warning("Failed to leave room when cleaning up room", exc_info=True)

    async def cleanup_portal(self, message: str, puppets_only: bool = False) -> None:
        if self.username:
@@ -335,12 +324,12 @@ class BasePortal(ABC):
        return DBPortal(tgid=self.tgid, tg_receiver=self.tg_receiver, peer_type=self.peer_type,
                        mxid=self.mxid, username=self.username, megagroup=self.megagroup,
                        title=self.title, about=self.about, photo_id=self.photo_id,
-                        config=json.dumps(self.local_config), encrypted=self.encrypted)
+                        config=json.dumps(self.local_config))

    def save(self) -> None:
        self.db_instance.edit(mxid=self.mxid, username=self.username, title=self.title,
                              about=self.about, photo_id=self.photo_id, megagroup=self.megagroup,
-                              config=json.dumps(self.local_config), encrypted=self.encrypted)
+                              config=json.dumps(self.local_config))

    def delete(self) -> None:
        try:
@@ -353,16 +342,15 @@ class BasePortal(ABC):
            pass
        if self._db_instance:
            self._db_instance.delete()
-        DBMessage.delete_all(self.mxid)
        self.deleted = True

    @classmethod
    def from_db(cls, db_portal: DBPortal) -> 'Portal':
        return cls(tgid=db_portal.tgid, tg_receiver=db_portal.tg_receiver,
-                   peer_type=db_portal.peer_type, mxid=db_portal.mxid, username=db_portal.username,
-                   megagroup=db_portal.megagroup, title=db_portal.title, about=db_portal.about,
-                   photo_id=db_portal.photo_id, local_config=db_portal.config,
-                   encrypted=db_portal.encrypted, db_instance=db_portal)
+                   peer_type=db_portal.peer_type, mxid=db_portal.mxid,
+                   username=db_portal.username, megagroup=db_portal.megagroup,
+                   title=db_portal.title, about=db_portal.about, photo_id=db_portal.photo_id,
+                   local_config=db_portal.config, db_instance=db_portal)

    # endregion
    # region Class instance lookup
@@ -404,8 +392,6 @@ class BasePortal(ABC):
    @classmethod
    def get_by_tgid(cls, tgid: TelegramID, tg_receiver: Optional[TelegramID] = None,
                    peer_type: str = None) -> Optional['Portal']:
-        if peer_type == "user" and tg_receiver is None:
-            raise ValueError("tg_receiver is required when peer_type is \"user\"")
        tg_receiver = tg_receiver or tgid
        tgid_full = (tgid, tg_receiver)
        try:
@@ -461,15 +447,6 @@ class BasePortal(ABC):
                               type_name if create else None)

    # endregion
-
-    async def _send_message(self, intent: IntentAPI, content: MessageEventContent,
-                            event_type: EventType = EventType.ROOM_MESSAGE, **kwargs) -> EventID:
-        if self.encrypted and self.matrix.e2ee:
-            if intent.api.is_real_user:
-                content[intent.api.real_user_content_key] = True
-            event_type, content = await self.matrix.e2ee.encrypt(self.mxid, event_type, content)
-        return await intent.send_message_event(self.mxid, event_type, content, **kwargs)
-
    # region Abstract methods (cross-called in matrix/metadata/telegram classes)

    @abstractmethod
@@ -511,12 +488,7 @@ class BasePortal(ABC):

    @abstractmethod
    def handle_matrix_power_levels(self, sender: 'u.User', new_levels: Dict[UserID, int],
-                                   old_levels: Dict[UserID, int], event_id: Optional[EventID]
-                                   ) -> Awaitable[None]:
-        pass
-
-    @abstractmethod
-    def backfill(self, source: 'AbstractUser') -> Awaitable[None]:
+                                   old_levels: Dict[UserID, int]) -> Awaitable[None]:
        pass

    # endregion
@@ -525,12 +497,10 @@ class BasePortal(ABC):
 def init(context: Context) -> None:
    global config
    BasePortal.az, config, BasePortal.loop, BasePortal.bot = context.core
-    BasePortal.matrix = context.mx
    BasePortal.max_initial_member_sync = config["bridge.max_initial_member_sync"]
    BasePortal.sync_channel_members = config["bridge.sync_channel_members"]
    BasePortal.sync_matrix_state = config["bridge.sync_matrix_state"]
    BasePortal.public_portals = config["bridge.public_portals"]
-    BasePortal.private_chat_portal_meta = config["bridge.private_chat_portal_meta"]
    BasePortal.filter_mode = config["bridge.filter.mode"]
    BasePortal.filter_list = config["bridge.filter.list"]
    BasePortal.hs_domain = config["homeserver.domain"]
@@ -1,5 +1,5 @@
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2020 Tulir Asokan
+# Copyright (C) 2019 Tulir Asokan
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -25,8 +25,7 @@ from telethon.tl.functions.messages import (EditChatPhotoRequest, EditChatTitleR
                                            EditChatAboutRequest)
 from telethon.tl.functions.channels import EditPhotoRequest, EditTitleRequest, JoinChannelRequest
 from telethon.errors import (ChatNotModifiedError, PhotoExtInvalidError,
-                             PhotoInvalidDimensionsError, PhotoSaveFileInvalidError,
-                             RPCError)
+                             PhotoInvalidDimensionsError, PhotoSaveFileInvalidError)
 from telethon.tl.patched import Message, MessageService
 from telethon.tl.types import (
    DocumentAttributeFilename, DocumentAttributeImageSize, GeoPoint,
@@ -51,11 +50,6 @@ if TYPE_CHECKING:
    from ..tgclient import MautrixTelegramClient
    from ..config import Config

-try:
-    from nio.crypto import decrypt_attachment
-except ImportError:
-    decrypt_attachment = None
-
 TypeMessage = Union[Message, MessageService]

 config: Optional['Config'] = None
@@ -229,13 +223,6 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
            message, entities = None, None
        return message, entities

-    async def _send_delivery_receipt(self, event_id: EventID) -> None:
-        if event_id and config["bridge.delivery_receipts"]:
-            try:
-                await self.az.intent.mark_read(self.mxid, event_id)
-            except Exception:
-                self.log.exception("Failed to send delivery receipt for %s", event_id)
-
    async def _handle_matrix_text(self, sender_id: TelegramID, event_id: EventID,
                                  space: TelegramID, client: 'MautrixTelegramClient',
                                  content: TextMessageEventContent, reply_to: TelegramID) -> None:
@@ -253,7 +240,6 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
                                                 parse_mode=self._matrix_event_to_entities,
                                                 link_preview=lp)
            self._add_telegram_message_to_db(event_id, space, 0, response)
-        await self._send_delivery_receipt(event_id)

    async def _handle_matrix_file(self, sender_id: TelegramID, event_id: EventID,
                                  space: TelegramID, client: 'MautrixTelegramClient',
@@ -264,20 +250,11 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
        file_name = content["net.maunium.telegram.internal.filename"]
        max_image_size = config["bridge.image_as_file_size"] * 1000 ** 2

-        if config["bridge.parallel_file_transfer"] and content.url:
+        if config["bridge.parallel_file_transfer"]:
            file_handle, file_size = await parallel_transfer_to_telegram(client, self.main_intent,
                                                                         content.url, sender_id)
        else:
-            if content.file:
-                if not decrypt_attachment:
-                    self.log.warning(f"Can't bridge encrypted media event {event_id}:"
-                                     " matrix-nio not installed")
-                    return
-                file = await self.main_intent.download_media(content.file.url)
-                file = decrypt_attachment(file, content.file.key.key,
-                                          content.file.hashes.get("sha256"), content.file.iv)
-            else:
-                file = await self.main_intent.download_media(content.url)
+            file = await self.main_intent.download_media(content.url)

            if content.msgtype == MessageType.STICKER:
                if mime != "image/gif":
@@ -316,7 +293,6 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
                response = await client.send_media(self.peer, media, reply_to=reply_to,
                                                   caption=caption, entities=entities)
            self._add_telegram_message_to_db(event_id, space, 0, response)
-        await self._send_delivery_receipt(event_id)

    async def _matrix_document_edit(self, client: 'MautrixTelegramClient',
                                    content: MessageEventContent, space: TelegramID,
@@ -327,7 +303,6 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
                response = await client.edit_message(self.peer, orig_msg.tgid,
                                                     caption, file=media)
                self._add_telegram_message_to_db(event_id, space, -1, response)
-                await self._send_delivery_receipt(event_id)
                return True
        return False

@@ -350,11 +325,10 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
            response = await client.send_media(self.peer, media, reply_to=reply_to,
                                               caption=caption, entities=entities)
            self._add_telegram_message_to_db(event_id, space, 0, response)
-        await self._send_delivery_receipt(event_id)

    def _add_telegram_message_to_db(self, event_id: EventID, space: TelegramID,
                                    edit_index: int, response: TypeMessage) -> None:
-        self.log.trace("Handled Matrix message: %s", response)
+        self.log.debug("Handled Matrix message: %s", response)
        self.dedup.check(response, (event_id, space), force_hash=edit_index != 0)
        if edit_index < 0:
            prev_edit = DBMessage.get_one_by_tgid(TelegramID(response.id), space, -1)
@@ -366,26 +340,17 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
            mxid=event_id,
            edit_index=edit_index).insert()

-    async def _send_bridge_error(self, msg: str) -> None:
-        if config["bridge.delivery_error_reports"]:
-            await self._send_message(self.main_intent,
-                                     TextMessageEventContent(msgtype=MessageType.NOTICE, body=msg))
-
    async def handle_matrix_message(self, sender: 'u.User', content: MessageEventContent,
                                    event_id: EventID) -> None:
-        try:
-            await self._handle_matrix_message(sender, content, event_id)
-        except RPCError as e:
-            if config["bridge.delivery_error_reports"]:
-                await self._send_bridge_error(f"\u26a0 Your message may not have been bridged: {e}")
-            raise
-
-    async def _handle_matrix_message(self, sender: 'u.User', content: MessageEventContent,
-                                     event_id: EventID) -> None:
        if not content.body or not content.msgtype:
            self.log.debug(f"Ignoring message {event_id} in {self.mxid} without body or msgtype")
            return

+        puppet = p.Puppet.get_by_custom_mxid(sender.mxid)
+        if puppet and content.get("net.maunium.telegram.puppet", False):
+            self.log.debug("Ignoring puppet-sent message by confirmed puppet user %s", sender.mxid)
+            return
+
        logged_in = not await sender.needs_relaybot(self)
        client = sender.client if logged_in else self.bot.client
        sender_id = sender.tgid if logged_in else self.bot.tgid
@@ -424,10 +389,10 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
            await self._handle_matrix_file(sender_id, event_id, space, client, content, reply_to,
                                           caption_content)
        else:
-            self.log.trace("Unhandled Matrix event: %s", content)
+            self.log.debug(f"Unhandled Matrix event: {content}")

-    async def handle_matrix_pin(self, sender: 'u.User', pinned_message: Optional[EventID],
-                                pin_event_id: EventID) -> None:
+    async def handle_matrix_pin(self, sender: 'u.User',
+                                pinned_message: Optional[EventID]) -> None:
        if self.peer_type != "chat" and self.peer_type != "channel":
            return
        try:
@@ -440,12 +405,10 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
                    self.log.warning(f"Could not find pinned {pinned_message} in {self.mxid}")
                    return
                await sender.client(UpdatePinnedMessageRequest(peer=self.peer, id=message.tgid))
-            await self._send_delivery_receipt(pin_event_id)
        except ChatNotModifiedError:
            pass

-    async def handle_matrix_deletion(self, deleter: 'u.User', event_id: EventID,
-                                     redaction_event_id: EventID) -> None:
+    async def handle_matrix_deletion(self, deleter: 'u.User', event_id: EventID) -> None:
        real_deleter = deleter if not await deleter.needs_relaybot(self) else self.bot
        space = self.tgid if self.peer_type == "channel" else real_deleter.tgid
        message = DBMessage.get_by_mxid(event_id, self.mxid, space)
@@ -453,7 +416,6 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
            return
        if message.edit_index == 0:
            await real_deleter.client.delete_messages(self.peer, [message.tgid])
-            await self._send_delivery_receipt(redaction_event_id)
        else:
            self.log.debug(f"Ignoring deletion of edit event {message.mxid} in {message.mx_room}")

@@ -468,8 +430,7 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
                                       pin_messages=moderator, add_admins=admin)

    async def handle_matrix_power_levels(self, sender: 'u.User', new_users: Dict[UserID, int],
-                                         old_users: Dict[UserID, int], event_id: Optional[EventID]
-                                         ) -> None:
+                                         old_users: Dict[UserID, int]) -> None:
        # TODO handle all power level changes and bridge exact admin rights to supergroups/channels
        for user, level in new_users.items():
            if not user or user == self.main_intent.mxid or user == sender.mxid:
@@ -485,16 +446,15 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
            if user not in old_users or level != old_users[user]:
                await self._update_telegram_power_level(sender, user_id, level)

-    async def handle_matrix_about(self, sender: 'u.User', about: str, event_id: EventID) -> None:
+    async def handle_matrix_about(self, sender: 'u.User', about: str) -> None:
        if self.peer_type not in ("chat", "channel"):
            return
        peer = await self.get_input_entity(sender)
        await sender.client(EditChatAboutRequest(peer=peer, about=about))
        self.about = about
        self.save()
-        await self._send_delivery_receipt(event_id)

-    async def handle_matrix_title(self, sender: 'u.User', title: str, event_id: EventID) -> None:
+    async def handle_matrix_title(self, sender: 'u.User', title: str) -> None:
        if self.peer_type not in ("chat", "channel"):
            return

@@ -506,10 +466,8 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
        self.dedup.register_outgoing_actions(response)
        self.title = title
        self.save()
-        await self._send_delivery_receipt(event_id)

-    async def handle_matrix_avatar(self, sender: 'u.User', url: ContentURI, event_id: EventID
-                                   ) -> None:
+    async def handle_matrix_avatar(self, sender: 'u.User', url: ContentURI) -> None:
        if self.peer_type not in ("chat", "channel"):
            # Invalid peer type
            return
@@ -535,10 +493,8 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
                self.photo_id = f"{size.location.volume_id}-{size.location.local_id}"
                self.save()
                break
-        await self._send_delivery_receipt(event_id)

-    async def handle_matrix_upgrade(self, sender: UserID, new_room: RoomID, event_id: EventID
-                                    ) -> None:
+    async def handle_matrix_upgrade(self, sender: UserID, new_room: RoomID) -> None:
        _, server = self.main_intent.parse_user_id(sender)
        old_room = self.mxid
        self.migrate_and_save_matrix(new_room)
@@ -565,7 +521,6 @@ class PortalMatrix(BasePortal, MautrixBasePortal, ABC):
            return
        await self.update_matrix_room(user, entity, direct=self.peer_type == "user")
        self.log.info(f"{sender} upgraded room from {old_room} to {self.mxid}")
-        await self._send_delivery_receipt(event_id)

    def migrate_and_save_matrix(self, new_id: RoomID) -> None:
        try:
@@ -1,5 +1,5 @@
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2020 Tulir Asokan
+# Copyright (C) 2019 Tulir Asokan
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -13,7 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import List, Optional, Tuple, Union, Callable, Awaitable, TYPE_CHECKING
+from typing import List, Optional, Tuple, Union, Callable, TYPE_CHECKING
 from abc import ABC
 import asyncio

@@ -26,13 +26,12 @@ from telethon.tl.types import (
    Channel, ChatBannedRights, ChannelParticipantsRecent, ChannelParticipantsSearch, ChatPhoto,
    PhotoEmpty, InputChannel, InputUser, ChatPhotoEmpty, PeerUser, Photo, TypeChat, TypeInputPeer,
    TypeUser, User, InputPeerPhotoFileLocation, ChatParticipantAdmin, ChannelParticipantAdmin,
-    ChatParticipantCreator, ChannelParticipantCreator, UserProfilePhoto, UserProfilePhotoEmpty)
+    ChatParticipantCreator, ChannelParticipantCreator)

 from mautrix.errors import MForbidden
 from mautrix.types import (RoomID, UserID, RoomCreatePreset, EventType, Membership, Member,
-                           PowerLevelStateEventContent, RoomTopicStateEventContent,
-                           RoomNameStateEventContent, RoomAvatarStateEventContent,
-                           StateEventContent)
+                           PowerLevelStateEventContent, RoomAlias)
+from mautrix.appservice import IntentAPI

 from ..types import TelegramID
 from ..context import Context
@@ -156,7 +155,7 @@ class PortalMetadata(BasePortal, ABC):
        if levels.get_user_level(self.main_intent.mxid) == 100:
            levels = self._get_base_power_levels(levels, entity)
            await self.main_intent.set_power_levels(self.mxid, levels)
-        await self.handle_matrix_power_levels(source, levels.users, {}, None)
+        await self.handle_matrix_power_levels(source, levels.users, {})

    async def invite_telegram(self, source: 'u.User',
                              puppet: Union[p.Puppet, 'AbstractUser']) -> None:
@@ -219,17 +218,10 @@ class PortalMetadata(BasePortal, ABC):
                puppet = p.Puppet.get(self.tgid)
            await puppet.update_info(user, entity)
            await puppet.intent_for(self).join_room(self.mxid)
-            if self.encrypted or self.private_chat_portal_meta:
-                # The bridge bot needs to join for e2ee, but that messes up the default name
-                # generation. If/when canonical DMs happen, this might not be necessary anymore.
-                changed = await self._update_title(puppet.displayname)
-                changed = await self._update_avatar(user, entity.photo) or changed
-                if changed:
-                    self.save()
        if self.sync_matrix_state:
            await self.sync_matrix_members()

-    async def create_matrix_room(self, user: 'AbstractUser', entity: Union[TypeChat, User] = None,
+    async def create_matrix_room(self, user: 'AbstractUser', entity: TypeChat = None,
                                 invites: InviteList = None, update_if_exists: bool = True,
                                 synchronous: bool = False) -> Optional[str]:
        if self.mxid:
@@ -253,13 +245,10 @@ class PortalMetadata(BasePortal, ABC):
            except Exception:
                self.log.exception("Fatal error creating Matrix room")

-    async def _create_matrix_room(self, user: 'AbstractUser', entity: Union[TypeChat, User],
-                                  invites: InviteList) -> Optional[RoomID]:
+    async def _create_matrix_room(self, user: 'AbstractUser', entity: TypeChat, invites: InviteList
+                                  ) -> Optional[RoomID]:
        direct = self.peer_type == "user"

-        if invites is None:
-            invites = []
-
        if self.mxid:
            return self.mxid

@@ -268,7 +257,7 @@ class PortalMetadata(BasePortal, ABC):

        if not entity:
            entity = await self.get_entity(user)
-            self.log.trace("Fetched data: %s", entity)
+            self.log.debug(f"Fetched data: {entity}")

        self.log.debug("Creating room")

@@ -282,8 +271,6 @@ class PortalMetadata(BasePortal, ABC):
            self.about = "Your Telegram cloud storage chat"

        puppet = p.Puppet.get(self.tgid) if direct else None
-        if puppet:
-            await puppet.update_info(user, entity)
        self._main_intent = puppet.intent_for(self) if direct else self.az.intent

        if self.peer_type == "channel":
@@ -317,41 +304,10 @@ class PortalMetadata(BasePortal, ABC):
            for invite in invites:
                power_levels.users.setdefault(invite, 100)
            self.title = puppet.displayname
-        bridge_info = {
-            "bridgebot": self.az.bot_mxid,
-            "creator": self.main_intent.mxid,
-            "protocol": {
-                "id": "telegram",
-                "displayname": "Telegram",
-                "avatar_url": config["appservice.bot_avatar"],
-            },
-            "channel": {
-                "id": self.tgid
-            }
-        }
        initial_state = [{
            "type": EventType.ROOM_POWER_LEVELS.serialize(),
            "content": power_levels.serialize(),
-        }, {
-            "type": "m.bridge",
-            "state_key": f"net.maunium.telegram://telegram/{self.tgid}",
-            "content": bridge_info
-        }, {
-            # TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec
-            "type": "uk.half-shot.bridge",
-            "state_key": f"net.maunium.telegram://telegram/{self.tgid}",
-            "content": bridge_info
        }]
-        if config["bridge.encryption.default"] and self.matrix.e2ee:
-            self.encrypted = True
-            initial_state.append({
-                "type": "m.room.encryption",
-                "content": {"algorithm": "m.megolm.v1.aes-sha2"},
-            })
-            if direct:
-                invites.append(self.az.bot_mxid)
-        if direct and (self.encrypted or self.private_chat_portal_meta):
-            self.title = puppet.displayname
        if config["appservice.community_id"]:
            initial_state.append({
                "type": "m.room.related_groups",
@@ -369,16 +325,6 @@ class PortalMetadata(BasePortal, ABC):
        if not room_id:
            raise Exception(f"Failed to create room")

-        if self.encrypted and self.matrix.e2ee:
-            members = [self.main_intent.mxid]
-            if direct:
-                try:
-                    await self.az.intent.join_room_by_id(room_id)
-                    members += [self.az.intent.mxid]
-                except Exception:
-                    self.log.warning(f"Failed to add bridge bot to new private chat {room_id}")
-            await self.matrix.e2ee.add_room(room_id, members=members, encrypted=True)
-
        self.mxid = RoomID(room_id)
        self.by_mxid[self.mxid] = self
        self.save()
@@ -416,7 +362,7 @@ class PortalMetadata(BasePortal, ABC):
            levels.kick = overrides.get("kick", 50)
            levels.redact = overrides.get("redact", 50)
            levels.invite = overrides.get("invite", 50 if dbr.invite_users else 0)
-            levels.events[EventType.ROOM_ENCRYPTION] = 99
+            levels.events[EventType.ROOM_ENCRYPTED] = 99
            levels.events[EventType.ROOM_TOMBSTONE] = 99
            levels.events[EventType.ROOM_NAME] = 50 if dbr.change_info else 0
            levels.events[EventType.ROOM_AVATAR] = 50 if dbr.change_info else 0
@@ -466,7 +412,7 @@ class PortalMetadata(BasePortal, ABC):
            return False
        changed = False
        admin_power_level = min(75 if self.peer_type == "channel" else 50, bot_level)
-        if levels.get_event_level(EventType.ROOM_POWER_LEVELS) != admin_power_level:
+        if levels.events[EventType.ROOM_POWER_LEVELS] != admin_power_level:
            changed = True
            levels.events[EventType.ROOM_POWER_LEVELS] = admin_power_level

@@ -596,12 +542,12 @@ class PortalMetadata(BasePortal, ABC):
            self.log.warning("Called update_info() for direct chat portal")
            return

-        changed = False
        self.log.debug("Updating info")
        try:
            if not entity:
                entity = await self.get_entity(user)
-                self.log.trace("Fetched data: %s", entity)
+                self.log.debug(f"Fetched data: {entity}")
+            changed = False

            if self.peer_type == "channel":
                changed = self.megagroup != entity.megagroup or changed
@@ -639,18 +585,15 @@ class PortalMetadata(BasePortal, ABC):
            self.save()
        return True

-    async def _try_set_state(self, sender: Optional['p.Puppet'], evt_type: EventType,
-                             content: StateEventContent) -> None:
+    async def _try_use_intent(self, sender: Optional['p.Puppet'],
+                              action: Callable[[IntentAPI], None]) -> None:
        if sender:
            try:
-                intent = sender.intent_for(self)
-                if sender.is_real_user:
-                    content[self.az.real_user_content_key] = True
-                await intent.send_state_event(self.mxid, evt_type, content)
+                await action(sender.intent_for(self))
            except MForbidden:
-                await self.main_intent.send_state_event(self.mxid, evt_type, content)
+                await action(self.main_intent)
        else:
-            await self.main_intent.send_state_event(self.mxid, evt_type, content)
+            await action(self.main_intent)

    async def _update_about(self, about: str, sender: Optional['p.Puppet'] = None,
                            save: bool = False) -> bool:
@@ -658,8 +601,8 @@ class PortalMetadata(BasePortal, ABC):
            return False

        self.about = about
-        await self._try_set_state(sender, EventType.ROOM_TOPIC,
-                                  RoomTopicStateEventContent(topic=self.about))
+        await self._try_use_intent(sender,
+                                   lambda intent: intent.set_room_topic(self.mxid, self.about))
        if save:
            self.save()
        return True
@@ -670,45 +613,42 @@ class PortalMetadata(BasePortal, ABC):
            return False

        self.title = title
-        await self._try_set_state(sender, EventType.ROOM_NAME,
-                                  RoomNameStateEventContent(name=self.title))
+        await self._try_use_intent(sender,
+                                   lambda intent: intent.set_room_name(self.mxid, self.title))
        if save:
            self.save()
        return True

    async def _update_avatar(self, user: 'AbstractUser', photo: TypeChatPhoto,
                             sender: Optional['p.Puppet'] = None, save: bool = False) -> bool:
-        if isinstance(photo, (ChatPhoto, UserProfilePhoto)):
+        if isinstance(photo, ChatPhoto):
            loc = InputPeerPhotoFileLocation(
                peer=await self.get_input_entity(user),
                local_id=photo.photo_big.local_id,
                volume_id=photo.photo_big.volume_id,
                big=True
            )
-            photo_id = (f"{loc.volume_id}-{loc.local_id}" if isinstance(photo, ChatPhoto)
-                        else photo.photo_id)
+            photo_id = f"{loc.volume_id}-{loc.local_id}"
        elif isinstance(photo, Photo):
            loc, largest = self._get_largest_photo_size(photo)
            photo_id = f"{largest.location.volume_id}-{largest.location.local_id}"
-        elif isinstance(photo, (UserProfilePhotoEmpty, ChatPhotoEmpty, PhotoEmpty, type(None))):
+        elif isinstance(photo, (ChatPhotoEmpty, PhotoEmpty)):
            photo_id = ""
            loc = None
        else:
            raise ValueError(f"Unknown photo type {type(photo)}")
-        if self.peer_type == "user" and not photo_id and not config["bridge.allow_avatar_remove"]:
-            return False
        if self.photo_id != photo_id:
            if not photo_id:
-                await self._try_set_state(sender, EventType.ROOM_AVATAR,
-                                          RoomAvatarStateEventContent(url=None))
+                await self._try_use_intent(sender,
+                                           lambda intent: intent.set_room_avatar(self.mxid, None))
                self.photo_id = ""
                if save:
                    self.save()
                return True
            file = await util.transfer_file_to_matrix(user.client, self.main_intent, loc)
            if file:
-                await self._try_set_state(sender, EventType.ROOM_AVATAR,
-                                          RoomAvatarStateEventContent(url=file.mxc))
+                await self._try_use_intent(sender, lambda intent: intent.set_room_avatar(self.mxid,
+                                                                                         file.mxc))
                self.photo_id = photo_id
                if save:
                    self.save()
@@ -1,5 +1,5 @@
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2020 Tulir Asokan
+# Copyright (C) 2019 Tulir Asokan
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from typing import Awaitable, Dict, List, Optional, Tuple, Union, NamedTuple, TYPE_CHECKING
+from html import escape as escape_html
 from abc import ABC
 import random
 import mimetypes
@@ -29,16 +30,16 @@ from telethon.tl.types import (
    MessageMediaPoll, MessageActionChannelCreate, MessageActionChatAddUser,
    MessageActionChatCreate, MessageActionChatDeletePhoto, MessageActionChatDeleteUser,
    MessageActionChatEditPhoto, MessageActionChatEditTitle, MessageActionChatJoinedByLink,
-    MessageActionChatMigrateTo, MessageActionGameScore, MessageMediaDocument, MessageMediaGeo,
-    MessageMediaPhoto, MessageMediaDice, MessageMediaGame, MessageMediaUnsupported, PeerUser,
-    PhotoCachedSize, TypeChannelParticipant, TypeChatParticipant, TypeDocumentAttribute,
-    TypeMessageAction, TypePhotoSize, PhotoSize, UpdateChatUserTyping, UpdateUserTyping,
-    MessageEntityPre, ChatPhotoEmpty)
+    MessageActionChatMigrateTo, MessageActionPinMessage, MessageActionGameScore,
+    MessageMediaDocument, MessageMediaGeo, MessageMediaPhoto, MessageMediaUnsupported,
+    MessageMediaGame, PeerUser, PhotoCachedSize, TypeChannelParticipant, TypeChatParticipant,
+    TypeDocumentAttribute, TypeMessageAction, TypePhotoSize, PhotoSize, UpdateChatUserTyping,
+    UpdateUserTyping, MessageEntityPre, ChatPhotoEmpty)

 from mautrix.appservice import IntentAPI
 from mautrix.types import (EventID, UserID, ImageInfo, ThumbnailInfo, RelatesTo, MessageType,
                           EventType, MediaMessageEventContent, TextMessageEventContent,
-                           LocationMessageEventContent, Format, MessageEventContent)
+                           LocationMessageEventContent, Format)

 from ..types import TelegramID
 from ..db import Message as DBMessage, TelegramFile as DBTelegramFile
@@ -72,10 +73,9 @@ class PortalTelegram(BasePortal, ABC):
        return None

    async def handle_telegram_photo(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
-                                    relates_to: RelatesTo = None) -> Optional[EventID]:
+                                    relates_to: Dict = None) -> Optional[EventID]:
        loc, largest_size = self._get_largest_photo_size(evt.media.photo)
-        file = await util.transfer_file_to_matrix(source.client, intent, loc,
-                                                  encrypt=self.encrypted)
+        file = await util.transfer_file_to_matrix(source.client, intent, loc)
        if not file:
            return None
        if self.get_config("inline_images") and (evt.message
@@ -86,26 +86,22 @@ class PortalTelegram(BasePortal, ABC):
                prefix_text="Inline image: ")
            content.external_url = self._get_external_url(evt)
            await intent.set_typing(self.mxid, is_typing=False)
-            return await self._send_message(intent, content, timestamp=evt.date)
+            return await intent.send_message(self.mxid, content, timestamp=evt.date)
        info = ImageInfo(
            height=largest_size.h, width=largest_size.w, orientation=0, mimetype=file.mime_type,
            size=(len(largest_size.bytes) if (isinstance(largest_size, PhotoCachedSize))
                  else largest_size.size))
        name = f"image{sane_mimetypes.guess_extension(file.mime_type)}"
        await intent.set_typing(self.mxid, is_typing=False)
-        content = MediaMessageEventContent(msgtype=MessageType.IMAGE, info=info,
+        content = MediaMessageEventContent(url=file.mxc, msgtype=MessageType.IMAGE, info=info,
                                           body=name, relates_to=relates_to,
                                           external_url=self._get_external_url(evt))
-        if file.decryption_info:
-            content.file = file.decryption_info
-        else:
-            content.url = file.mxc
-        result = await self._send_message(intent, content, timestamp=evt.date)
+        result = await intent.send_message(self.mxid, content, timestamp=evt.date)
        if evt.message:
            caption_content = await formatter.telegram_to_matrix(evt, source, self.main_intent,
                                                                 no_reply_fallback=True)
            caption_content.external_url = content.external_url
-            result = await self._send_message(intent, caption_content, timestamp=evt.date)
+            result = await intent.send_message(self.mxid, caption_content, timestamp=evt.date)
        return result

    @staticmethod
@@ -138,8 +134,6 @@ class PortalTelegram(BasePortal, ABC):
        generic_types = ("text/plain", "application/octet-stream")
        if file.mime_type in generic_types and document.mime_type not in generic_types:
            mime_type = document.mime_type or file.mime_type
-        elif file.mime_type == 'application/ogg':
-            mime_type = 'audio/ogg'
        else:
            mime_type = file.mime_type or document.mime_type
        info = ImageInfo(size=file.size, mimetype=mime_type)
@@ -152,21 +146,11 @@ class PortalTelegram(BasePortal, ABC):
            info.width, info.height = attrs.width, attrs.height

        if file.thumbnail:
-            if file.thumbnail.decryption_info:
-                info.thumbnail_file = file.thumbnail.decryption_info
-            else:
-                info.thumbnail_url = file.thumbnail.mxc
+            info.thumbnail_url = file.thumbnail.mxc
            info.thumbnail_info = ThumbnailInfo(mimetype=file.thumbnail.mime_type,
                                                height=file.thumbnail.height or thumb_size.h,
                                                width=file.thumbnail.width or thumb_size.w,
                                                size=file.thumbnail.size)
-        else:
-            # This is a hack for bad clients like Riot iOS that require a thumbnail
-            if file.decryption_info:
-                info.thumbnail_file = file.decryption_info
-            else:
-                info.thumbnail_url = file.mxc
-            info.thumbnail_info = ImageInfo.deserialize(info.serialize())

        return info, name

@@ -180,7 +164,6 @@ class PortalTelegram(BasePortal, ABC):
        if document.size > config["bridge.max_document_size"] * 1000 ** 2:
            name = attrs.name or ""
            caption = f"\n{evt.message}" if evt.message else ""
-            # TODO encrypt
            return await intent.send_notice(self.mxid, f"Too large file {name}{caption}")

        thumb_loc, thumb_size = self._get_largest_photo_size(document)
@@ -192,8 +175,7 @@ class PortalTelegram(BasePortal, ABC):
        file = await util.transfer_file_to_matrix(source.client, intent, document, thumb_loc,
                                                  is_sticker=attrs.is_sticker,
                                                  tgs_convert=config["bridge.animated_sticker"],
-                                                  filename=attrs.name, parallel_id=parallel_id,
-                                                  encrypt=self.encrypted)
+                                                  filename=attrs.name, parallel_id=parallel_id)
        if not file:
            return None

@@ -206,21 +188,17 @@ class PortalTelegram(BasePortal, ABC):
        if attrs.is_sticker and file.mime_type.startswith("image/"):
            event_type = EventType.STICKER
        content = MediaMessageEventContent(
-            body=name or "unnamed file", info=info, relates_to=relates_to,
+            body=name or "unnamed file", info=info, url=file.mxc, relates_to=relates_to,
            external_url=self._get_external_url(evt),
            msgtype={
                "video/": MessageType.VIDEO,
                "audio/": MessageType.AUDIO,
                "image/": MessageType.IMAGE,
            }.get(info.mimetype[:6], MessageType.FILE))
-        if file.decryption_info:
-            content.file = file.decryption_info
-        else:
-            content.url = file.mxc
-        return await self._send_message(intent, content, event_type=event_type, timestamp=evt.date)
+        return await intent.send_message_event(self.mxid, event_type, content, timestamp=evt.date)

-    def handle_telegram_location(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
-                                 relates_to: RelatesTo = None) -> Awaitable[EventID]:
+    def handle_telegram_location(self, _: 'AbstractUser', intent: IntentAPI, evt: Message,
+                                 relates_to: dict = None) -> Awaitable[EventID]:
        long = evt.media.geo.long
        lat = evt.media.geo.lat
        long_char = "E" if long > 0 else "W"
@@ -236,7 +214,7 @@ class PortalTelegram(BasePortal, ABC):
        content["format"] = str(Format.HTML)
        content["formatted_body"] = f"Location: <a href='{url}'>{body}</a>"

-        return self._send_message(intent, content, timestamp=evt.date)
+        return intent.send_message(self.mxid, content, timestamp=evt.date)

    async def handle_telegram_text(self, source: 'AbstractUser', intent: IntentAPI, is_bot: bool,
                                   evt: Message) -> EventID:
@@ -246,10 +224,10 @@ class PortalTelegram(BasePortal, ABC):
        if is_bot and self.get_config("bot_messages_as_notices"):
            content.msgtype = MessageType.NOTICE
        await intent.set_typing(self.mxid, is_typing=False)
-        return await self._send_message(intent, content, timestamp=evt.date)
+        return await intent.send_message(self.mxid, content, timestamp=evt.date)

    async def handle_telegram_unsupported(self, source: 'AbstractUser', intent: IntentAPI,
-                                          evt: Message, relates_to: RelatesTo = None) -> EventID:
+                                          evt: Message, relates_to: dict = None) -> EventID:
        override_text = ("This message is not supported on your version of Mautrix-Telegram. "
                         "Please check https://github.com/tulir/mautrix-telegram or ask your "
                         "bridge administrator about possible updates.")
@@ -259,7 +237,7 @@ class PortalTelegram(BasePortal, ABC):
        content.external_url = self._get_external_url(evt)
        content["net.maunium.telegram.unsupported"] = True
        await intent.set_typing(self.mxid, is_typing=False)
-        return await self._send_message(intent, content, timestamp=evt.date)
+        return await intent.send_message(self.mxid, content, timestamp=evt.date)

    async def handle_telegram_poll(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
                                   relates_to: RelatesTo) -> EventID:
@@ -285,26 +263,11 @@ class PortalTelegram(BasePortal, ABC):
            relates_to=relates_to, external_url=self._get_external_url(evt))

        await intent.set_typing(self.mxid, is_typing=False)
-        return await self._send_message(intent, content, timestamp=evt.date)
-
-    async def handle_telegram_dice(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
-                                   relates_to: RelatesTo) -> EventID:
-        emoji_text = {
-            "\U0001F3AF": " Dart throw",
-            "\U0001F3B2": " Dice roll",
-        }
-        roll: MessageMediaDice = evt.media
-        text = f"{roll.emoticon}{emoji_text.get(roll.emoticon, '')} result: {roll.value}"
-        content = TextMessageEventContent(msgtype=MessageType.TEXT, format=Format.HTML, body=text,
-                                          formatted_body=f"<h4>{text}</h4>", relates_to=relates_to,
-                                          external_url=self._get_external_url(evt))
-        content["net.maunium.telegram.dice"] = {"emoticon": roll.emoticon, "value": roll.value}
-        await intent.set_typing(self.mxid, is_typing=False)
-        return await self._send_message(intent, content, timestamp=evt.date)
+        return await intent.send_message(self.mxid, content, timestamp=evt.date)

    @staticmethod
    def _int_to_bytes(i: int) -> bytes:
-        hex_value = "{0:010x}".format(i).encode("utf-8")
+        hex_value = "{0:010x}".format(i)
        return codecs.decode(hex_value, "hex_codec")

    def _encode_msgid(self, source: 'AbstractUser', evt: Message) -> str:
@@ -342,12 +305,11 @@ class PortalTelegram(BasePortal, ABC):
        content["net.maunium.telegram.game"] = play_id

        await intent.set_typing(self.mxid, is_typing=False)
-        return await self._send_message(intent, content, timestamp=evt.date)
+        return await intent.send_message(self.mxid, content, timestamp=evt.date)

    async def handle_telegram_edit(self, source: 'AbstractUser', sender: p.Puppet, evt: Message
                                   ) -> None:
        if not self.mxid:
-            self.log.trace("Ignoring edit to %d as chat has no Matrix room", evt.id)
            return
        elif hasattr(evt, "media") and isinstance(evt.media, MessageMediaGame):
            self.log.debug("Ignoring game message edit event")
@@ -387,54 +349,16 @@ class PortalTelegram(BasePortal, ABC):

        intent = sender.intent_for(self) if sender else self.main_intent
        await intent.set_typing(self.mxid, is_typing=False)
-        event_id = await self._send_message(intent, content)
+        event_id = await intent.send_message(self.mxid, content)

        prev_edit_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space, -1) or editing_msg
        DBMessage(mxid=event_id, mx_room=self.mxid, tg_space=tg_space, tgid=TelegramID(evt.id),
                  edit_index=prev_edit_msg.edit_index + 1).insert()
        DBMessage.update_by_mxid(temporary_identifier, self.mxid, mxid=event_id)

-    async def backfill(self, source: 'AbstractUser') -> None:
-        self.log.debug("Backfilling history through %s", source.mxid)
-        last = DBMessage.find_last(self.mxid, (source.tgid if self.peer_type != "channel"
-                                               else self.tgid))
-        min_id = last.tgid if last else 0
-        self.backfilling = True
-        self.backfill_leave = set()
-        if self.peer_type == "user":
-            self.log.debug("Adding %s's default puppet to room for backfilling", source.mxid)
-            sender = p.Puppet.get(source.tgid)
-            await self.main_intent.invite_user(self.mxid, sender.default_mxid)
-            await sender.default_mxid_intent.join_room_by_id(self.mxid)
-            self.backfill_leave.add(sender.default_mxid_intent)
-        max_file_size = min(config["bridge.max_document_size"], 1500) * 1024 * 1024
-        self.log.trace("Opening takeout client for %d, message ID %d->", source.tgid, min_id)
-        count = 0
-        async with source.client.takeout(files=True, megagroups=self.megagroup,
-                                         chats=self.peer_type == "chat",
-                                         users=self.peer_type == "user",
-                                         channels=(self.peer_type == "channel"
-                                                   and not self.megagroup),
-                                         max_file_size=max_file_size
-                                         ) as takeout_client:
-            async for message in takeout_client.iter_messages(await self.get_input_entity(source),
-                                                              reverse=True, min_id=min_id):
-                sender = p.Puppet.get(message.sender_id)
-                # if isinstance(message, MessageService):
-                #    await self.handle_telegram_action(source, sender, message)
-                await self.handle_telegram_message(source, sender, message)
-                count += 1
-        for intent in self.backfill_leave:
-            self.log.trace("Leaving room with %s post-backfill", intent.mxid)
-            await intent.leave_room(self.mxid)
-        self.backfilling = False
-        self.backfill_leave = None
-        self.log.info("Backfilled %d messages through %s", count, source.mxid)
-
    async def handle_telegram_message(self, source: 'AbstractUser', sender: p.Puppet,
                                      evt: Message) -> None:
        if not self.mxid:
-            self.log.trace("Got telegram message %d, but no room exists, creating...", evt.id)
            await self.create_matrix_room(source, invites=[source.mxid], update_if_exists=False)

        if (self.peer_type == "user" and sender.tgid == self.tg_receiver
@@ -459,7 +383,7 @@ class PortalTelegram(BasePortal, ABC):
                              tg_space=tg_space, edit_index=0).insert()
                return

-        if self.backfilling or (self.dedup.pre_db_check and self.peer_type == "channel"):
+        if self.dedup.pre_db_check and self.peer_type == "channel":
            msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space)
            if msg:
                self.log.debug(f"Ignoring message {evt.id} (src {source.tgid}) as it was already"
@@ -468,8 +392,6 @@ class PortalTelegram(BasePortal, ABC):
                               "bridge.deduplication.cache_queue_length in the config.")
                return

-        self.log.trace("Handling Telegram message %s", evt)
-
        if sender and not sender.displayname:
            self.log.debug(f"Telegram user {sender.tgid} sent a message, but doesn't have a "
                           "displayname, updating info...")
@@ -477,17 +399,10 @@ class PortalTelegram(BasePortal, ABC):
            await sender.update_info(source, entity)

        allowed_media = (MessageMediaPhoto, MessageMediaDocument, MessageMediaGeo,
-                         MessageMediaGame, MessageMediaDice, MessageMediaPoll,
-                         MessageMediaUnsupported)
+                         MessageMediaGame, MessageMediaPoll, MessageMediaUnsupported)
        media = evt.media if hasattr(evt, "media") and isinstance(evt.media,
                                                                  allowed_media) else None
-        if sender:
-            intent = sender.intent_for(self)
-            if self.backfilling and intent != sender.default_mxid_intent:
-                intent = sender.default_mxid_intent
-                self.backfill_leave.add(intent)
-        else:
-            intent = self.main_intent
+        intent = sender.intent_for(self) if sender else self.main_intent
        if not media and evt.message:
            is_bot = sender.is_bot if sender else False
            event_id = await self.handle_telegram_text(source, intent, is_bot, evt)
@@ -497,13 +412,12 @@ class PortalTelegram(BasePortal, ABC):
                MessageMediaDocument: self.handle_telegram_document,
                MessageMediaGeo: self.handle_telegram_location,
                MessageMediaPoll: self.handle_telegram_poll,
-                MessageMediaDice: self.handle_telegram_dice,
                MessageMediaUnsupported: self.handle_telegram_unsupported,
                MessageMediaGame: self.handle_telegram_game,
            }[type(media)](source, intent, evt,
                           relates_to=formatter.telegram_reply_to_matrix(evt, source))
        else:
-            self.log.debug("Unhandled Telegram message %d", evt.id)
+            self.log.debug("Unhandled Telegram message: %s", evt)
            return

        if not event_id:
@@ -520,7 +434,7 @@ class PortalTelegram(BasePortal, ABC):
            await intent.redact(self.mxid, event_id)
            return

-        self.log.debug("Handled telegram message %d -> %s", evt.id, event_id)
+        self.log.debug("Handled Telegram message: %s", evt)
        try:
            DBMessage(tgid=TelegramID(evt.id), mx_room=self.mxid, mxid=event_id,
                      tg_space=tg_space, edit_index=0).insert()
@@ -568,14 +482,13 @@ class PortalTelegram(BasePortal, ABC):
        elif isinstance(action, MessageActionChatMigrateTo):
            self.peer_type = "channel"
            self._migrate_and_save_telegram(TelegramID(action.channel_id))
-            # TODO encrypt
            await sender.intent_for(self).send_emote(self.mxid,
                                                     "upgraded this group to a supergroup.")
        elif isinstance(action, MessageActionGameScore):
            # TODO handle game score
            pass
        else:
-            self.log.trace("Unhandled Telegram action in %s: %s", self.title, action)
+            self.log.debug("Unhandled Telegram action in %s: %s", self.title, action)

    async def set_telegram_admin(self, user_id: TelegramID) -> None:
        puppet = p.Puppet.get(user_id)
@@ -589,7 +502,7 @@ class PortalTelegram(BasePortal, ABC):
        await self.main_intent.set_power_levels(self.mxid, levels)

    async def receive_telegram_pin_id(self, msg_id: TelegramID, receiver: TelegramID) -> None:
-        tg_space = receiver if self.peer_type != "channel" else self.tgid
+        tg_space = receiver  if self.peer_type != "channel" else self.tgid
        message = DBMessage.get_one_by_tgid(msg_id, tg_space) if msg_id != 0 else None
        if message:
            await self.main_intent.set_pinned_messages(self.mxid, [message.mxid])
@@ -1,5 +1,5 @@
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2020 Tulir Asokan
+# Copyright (C) 2019 Tulir Asokan
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -242,7 +242,8 @@ class Puppet(CustomPuppetMixin):

        try:
            changed = await self.update_displayname(source, info) or changed
-            changed = await self.update_avatar(source, info.photo) or changed
+            if isinstance(info.photo, UserProfilePhoto):
+                changed = await self.update_avatar(source, info.photo) or changed
        except Exception:
            self.log.exception(f"Failed to update info from source {source.tgid}")

@@ -255,24 +256,19 @@ class Puppet(CustomPuppetMixin):
                                 ) -> bool:
        if self.disable_updates:
            return False
-        if source.is_relaybot or source.is_bot:
-            allow_because = "user is bot"
-        elif self.displayname_source == source.tgid:
-            allow_because = "user is the primary source"
-        elif not info.contact:
-            allow_because = "user is not a contact"
-        elif self.displayname_source is None:
-            allow_because = "no primary source set"
-        else:
+        allow_source = (source.is_relaybot
+                        or self.displayname_source == source.tgid
+                        # User is not a contact, so there's no custom name
+                        or not info.contact
+                        # No displayname source, so just trust anything
+                        or self.displayname_source is None)
+        if not allow_source:
            return False
-
-        if isinstance(info, UpdateUserName):
+        elif isinstance(info, UpdateUserName):
            info = await source.client.get_entity(PeerUser(self.tgid))

        displayname = self.get_displayname(info)
        if displayname != self.displayname:
-            self.log.debug(f"Updating displayname of {self.id} (src: {source.tgid}, allowed "
-                           f"because {allow_because}) from {self.displayname} to {displayname}")
            self.displayname = displayname
            self.displayname_source = source.tgid
            try:
@@ -293,15 +289,10 @@ class Puppet(CustomPuppetMixin):
        if self.disable_updates:
            return False

-        if photo is None or isinstance(photo, UserProfilePhotoEmpty):
+        if isinstance(photo, UserProfilePhotoEmpty):
            photo_id = ""
-        elif isinstance(photo, UserProfilePhoto):
-            photo_id = str(photo.photo_id)
        else:
-            self.log.warning(f"Unknown user profile photo type: {type(photo)}")
-            return False
-        if not photo_id and not config["bridge.allow_avatar_remove"]:
-            return False
+            photo_id = str(photo.photo_id)
        if self.photo_id != photo_id:
            if not photo_id:
                self.photo_id = ""
@@ -381,7 +372,7 @@ class Puppet(CustomPuppetMixin):

    @classmethod
    def all_with_custom_mxid(cls) -> Iterable['Puppet']:
-        return (cls.by_custom_mxid[puppet.custom_mxid]
+        return (cls.by_custom_mxid[puppet.mxid]
                if puppet.custom_mxid in cls.by_custom_mxid
                else cls.from_db(puppet)
                for puppet in DBPuppet.all_with_custom_mxid())
@@ -29,7 +29,6 @@ from mautrix.client import Client
 from mautrix.errors import MatrixRequestError
 from mautrix.types import UserID
 from mautrix.bridge import BaseUser
-from mautrix.util.logging import TraceLogger

 from .types import TelegramID
 from .db import User as DBUser
@@ -46,7 +45,7 @@ SearchResult = NewType('SearchResult', Tuple['pu.Puppet', int])


 class User(AbstractUser, BaseUser):
-    log: TraceLogger = logging.getLogger("mau.user")
+    log: logging.Logger = logging.getLogger("mau.user")
    by_mxid: Dict[str, 'User'] = {}
    by_tgid: Dict[int, 'User'] = {}

@@ -344,14 +343,12 @@ class User(AbstractUser, BaseUser):
            entity = dialog.entity
            if isinstance(entity, ChatForbidden):
                self.log.warning(f"Ignoring forbidden chat {entity} while syncing")
-                continue
            elif isinstance(entity, Chat) and (entity.deactivated or entity.left):
                self.log.warning(f"Ignoring deactivated or left chat {entity} while syncing")
                continue
            elif isinstance(entity, TLUser) and not config["bridge.sync_direct_chats"]:
-                self.log.trace(f"Ignoring user {entity.id} while syncing")
                continue
-            portal = po.Portal.get_by_entity(entity, receiver_id=self.tgid)
+            portal = po.Portal.get_by_entity(entity)
            self.portals[portal.tgid_full] = portal
            creators.append(
                portal.create_matrix_room(self, entity, invites=[self.mxid],
@@ -13,8 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from mautrix.util.logging.color import (ColorFormatter as BaseColorFormatter,
-                                        PREFIX, MXID_COLOR, RESET)
+from mautrix.util.color_log import ColorFormatter as BaseColorFormatter, PREFIX, MXID_COLOR, RESET

 TELETHON_COLOR = PREFIX + "35;1m"  # magenta
 TELETHON_MODULE_COLOR = PREFIX + "35m"
@@ -18,7 +18,6 @@ from io import BytesIO
 import time
 import logging
 import asyncio
-import tempfile

 import magic
 from sqlalchemy.exc import IntegrityError, InvalidRequestError
@@ -30,13 +29,12 @@ from telethon.errors import (AuthBytesInvalidError, AuthKeyInvalidError, Locatio
                             SecurityError, FileIdInvalidError)

 from mautrix.appservice import IntentAPI
-from mautrix.types import EncryptedFile
+

 from ..tgclient import MautrixTelegramClient
 from ..db import TelegramFile as DBTelegramFile
 from ..util import sane_mimetypes
 from .parallel_file_transfer import parallel_transfer_to_matrix
-from .tgs_converter import convert_tgs_to

 try:
    from PIL import Image
@@ -45,13 +43,14 @@ except ImportError:

 try:
    from moviepy.editor import VideoFileClip
+    import random
+    import string
+    import os
+    import mimetypes
 except ImportError:
-    VideoFileClip = None
+    VideoFileClip = random = string = os = mimetypes = None

-try:
-    from nio.crypto import encrypt_attachment
-except ImportError:
-    encrypt_attachment = None
+from .tgs_converter import convert_tgs_to

 log: logging.Logger = logging.getLogger("mau.util")

@@ -77,23 +76,32 @@ def convert_image(file: bytes, source_mime: str = "image/webp", target_type: str
        return source_mime, file, None, None


+def _temp_file_name(ext: str) -> str:
+    return ("/tmp/mxtg-video-"
+            + "".join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10))
+            + ext)
+
+
 def _read_video_thumbnail(data: bytes, video_ext: str = "mp4", frame_ext: str = "png",
                          max_size: Tuple[int, int] = (1024, 720)) -> Tuple[bytes, int, int]:
-    with tempfile.NamedTemporaryFile(prefix="mxtg_video_", suffix=f".{video_ext}") as file:
-        # We don't have any way to read the video from memory, so save it to disk.
+    # We don't have any way to read the video from memory, so save it to disk.
+    temp_file = _temp_file_name(video_ext)
+    with open(temp_file, "wb") as file:
        file.write(data)

-        # Read temp file and get frame
-        frame = VideoFileClip(file.name).get_frame(0)
+    # Read temp file and get frame
+    clip = VideoFileClip(temp_file)
+    frame = clip.get_frame(0)

    # Convert to png and save to BytesIO
    image = Image.fromarray(frame).convert("RGBA")
-
    thumbnail_file = BytesIO()
    if max_size:
        image.thumbnail(max_size, Image.ANTIALIAS)
    image.save(thumbnail_file, frame_ext)

+    os.remove(temp_file)
+
    w, h = image.size
    return thumbnail_file.getvalue(), w, h

@@ -108,8 +116,8 @@ def _location_to_id(location: TypeLocation) -> str:


 async def transfer_thumbnail_to_matrix(client: MautrixTelegramClient, intent: IntentAPI,
-                                       thumbnail_loc: TypeLocation, video: bytes, mime: str,
-                                       encrypt: bool) -> Optional[DBTelegramFile]:
+                                       thumbnail_loc: TypeLocation, video: bytes,
+                                       mime: str) -> Optional[DBTelegramFile]:
    if not Image or not VideoFileClip:
        return None

@@ -133,19 +141,11 @@ async def transfer_thumbnail_to_matrix(client: MautrixTelegramClient, intent: In
        width, height = None, None
        mime_type = magic.from_buffer(file, mime=True)

-    decryption_info = None
-    upload_mime_type = mime_type
-    if encrypt:
-        file, decryption_info_dict = encrypt_attachment(file)
-        decryption_info = EncryptedFile.deserialize(decryption_info_dict)
-        upload_mime_type = "application/octet-stream"
-    content_uri = await intent.upload_media(file, upload_mime_type)
-    if decryption_info:
-        decryption_info.url = content_uri
+    content_uri = await intent.upload_media(file, mime_type)

    db_file = DBTelegramFile(id=loc_id, mxc=content_uri, mime_type=mime_type,
                             was_converted=False, timestamp=int(time.time()), size=len(file),
-                             width=width, height=height, decryption_info=decryption_info)
+                             width=width, height=height)
    try:
        db_file.insert()
    except (IntegrityError, InvalidRequestError) as e:
@@ -161,10 +161,10 @@ TypeThumbnail = Optional[Union[TypeLocation, TypePhotoSize]]


 async def transfer_file_to_matrix(client: MautrixTelegramClient, intent: IntentAPI,
-                                  location: TypeLocation, thumbnail: TypeThumbnail = None, *,
+                                  location: TypeLocation, thumbnail: TypeThumbnail = None,
                                  is_sticker: bool = False, tgs_convert: Optional[dict] = None,
-                                  filename: Optional[str] = None, encrypt: bool = False,
-                                  parallel_id: Optional[int] = None) -> Optional[DBTelegramFile]:
+                                  filename: Optional[str] = None, parallel_id: Optional[int] = None
+                                  ) -> Optional[DBTelegramFile]:
    location_id = _location_to_id(location)
    if not location_id:
        return None
@@ -181,14 +181,14 @@ async def transfer_file_to_matrix(client: MautrixTelegramClient, intent: IntentA
    async with lock:
        return await _unlocked_transfer_file_to_matrix(client, intent, location_id, location,
                                                       thumbnail, is_sticker, tgs_convert,
-                                                       filename, encrypt, parallel_id)
+                                                       filename, parallel_id)


 async def _unlocked_transfer_file_to_matrix(client: MautrixTelegramClient, intent: IntentAPI,
                                            loc_id: str, location: TypeLocation,
                                            thumbnail: TypeThumbnail, is_sticker: bool,
                                            tgs_convert: Optional[dict], filename: Optional[str],
-                                            encrypt: bool, parallel_id: Optional[int]
+                                            parallel_id: Optional[int]
                                            ) -> Optional[DBTelegramFile]:
    db_file = DBTelegramFile.get(loc_id)
    if db_file:
@@ -196,7 +196,7 @@ async def _unlocked_transfer_file_to_matrix(client: MautrixTelegramClient, inten

    if parallel_id and isinstance(location, Document) and (not is_sticker or not tgs_convert):
        db_file = await parallel_transfer_to_matrix(client, intent, loc_id, location, filename,
-                                                    encrypt, parallel_id)
+                                                    parallel_id)
        mime_type = location.mime_type
        file = None
    else:
@@ -214,8 +214,8 @@ async def _unlocked_transfer_file_to_matrix(client: MautrixTelegramClient, inten
        image_converted = False
        # A weird bug in alpine/magic makes it return application/octet-stream for gzips...
        if is_sticker and tgs_convert and (mime_type == "application/gzip" or (
-            mime_type == "application/octet-stream"
-            and magic.from_buffer(file).startswith("gzip"))):
+               mime_type == "application/octet-stream"
+               and magic.from_buffer(file).startswith("gzip"))):
            mime_type, file, width, height = await convert_tgs_to(
                file, tgs_convert["target"], **tgs_convert["args"])
            thumbnail = None
@@ -229,28 +229,17 @@ async def _unlocked_transfer_file_to_matrix(client: MautrixTelegramClient, inten
            mime_type = new_mime_type
            thumbnail = None

-        decryption_info = None
-        upload_mime_type = mime_type
-        if encrypt and encrypt_attachment:
-            file, decryption_info_dict = encrypt_attachment(file)
-            decryption_info = EncryptedFile.deserialize(decryption_info_dict)
-            upload_mime_type = "application/octet-stream"
-        content_uri = await intent.upload_media(file, upload_mime_type)
-        if decryption_info:
-            decryption_info.url = content_uri
+        content_uri = await intent.upload_media(file, mime_type)

-        db_file = DBTelegramFile(id=loc_id, mxc=content_uri, decryption_info=decryption_info,
+        db_file = DBTelegramFile(id=loc_id, mxc=content_uri,
                                 mime_type=mime_type, was_converted=image_converted,
                                 timestamp=int(time.time()), size=len(file),
                                 width=width, height=height)
    if thumbnail and (mime_type.startswith("video/") or mime_type == "image/gif"):
        if isinstance(thumbnail, (PhotoSize, PhotoCachedSize)):
            thumbnail = thumbnail.location
-        try:
-            db_file.thumbnail = await transfer_thumbnail_to_matrix(client, intent, thumbnail, file,
-                                                                   mime_type, encrypt)
-        except FileIdInvalidError:
-            log.warning(f"Failed to transfer thumbnail for {thumbnail!s}", exc_info=True)
+        db_file.thumbnail = await transfer_thumbnail_to_matrix(client, intent, thumbnail, file,
+                                                               mime_type)

    try:
        db_file.insert()
@@ -13,7 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Optional, List, AsyncGenerator, Union, Awaitable, DefaultDict, Tuple, cast
+from typing import Optional, List, AsyncGenerator, Union, Awaitable, DefaultDict, Tuple
 from collections import defaultdict
 import hashlib
 import asyncio
@@ -34,18 +34,12 @@ from telethon.crypto import AuthKey
 from telethon import utils, helpers

 from mautrix.appservice import IntentAPI
-from mautrix.types import ContentURI, EncryptedFile
-from mautrix.util.logging import TraceLogger
+from mautrix.types import ContentURI

 from ..tgclient import MautrixTelegramClient
 from ..db import TelegramFile as DBTelegramFile

-try:
-    from nio.crypto import async_encrypt_attachment
-except ImportError:
-    async_encrypt_attachment = None
-
-log: TraceLogger = cast(TraceLogger, logging.getLogger("mau.util"))
+log: logging.Logger = logging.getLogger("mau.util")

 TypeLocation = Union[Document, InputDocumentFileLocation, InputPeerPhotoFileLocation,
                     InputFileLocation, InputPhotoFileLocation]
@@ -103,7 +97,7 @@ class UploadSender:

    async def _next(self, data: bytes) -> None:
        self.request.bytes = data
-        log.trace(f"Sending file part {self.request.file_part}/{self.part_count}"
+        log.debug(f"Sending file part {self.request.file_part}/{self.part_count}"
                  f" with {len(data)} bytes")
        await self.sender.send(self.request)
        self.request.file_part += self.stride
@@ -237,7 +231,7 @@ class ParallelTransferrer:
                    break
                yield data
                part += 1
-                log.trace(f"Part {part} downloaded")
+                log.debug(f"Part {part} downloaded")

        log.debug("Parallel download finished, cleaning up connections")
        await self._cleanup()
@@ -248,34 +242,18 @@ parallel_transfer_locks: DefaultDict[int, asyncio.Lock] = defaultdict(lambda: as

 async def parallel_transfer_to_matrix(client: MautrixTelegramClient, intent: IntentAPI,
                                      loc_id: str, location: TypeLocation, filename: str,
-                                      encrypt: bool, parallel_id: int) -> DBTelegramFile:
+                                      parallel_id: int) -> DBTelegramFile:
    size = location.size
    mime_type = location.mime_type
    dc_id, location = utils.get_input_location(location)
    # We lock the transfers because telegram has connection count limits
    async with parallel_transfer_locks[parallel_id]:
        downloader = ParallelTransferrer(client, dc_id)
-        data = downloader.download(location, size)
-        decryption_info = None
-        up_mime_type = mime_type
-        if encrypt and async_encrypt_attachment:
-            async def encrypted(stream):
-                nonlocal decryption_info
-                async for chunk in async_encrypt_attachment(stream):
-                    if isinstance(chunk, dict):
-                        decryption_info = EncryptedFile.deserialize(chunk)
-                    else:
-                        yield chunk
-
-            data = encrypted(data)
-            up_mime_type = "application/octet-stream"
-        content_uri = await intent.upload_media(data, mime_type=up_mime_type, filename=filename,
-                                                size=size if not encrypt else None)
-        if decryption_info:
-            decryption_info.url = content_uri
+        content_uri = await intent.upload_media(downloader.download(location, size),
+                                                mime_type=mime_type, filename=filename, size=size)
    return DBTelegramFile(id=loc_id, mxc=content_uri, mime_type=mime_type,
                          was_converted=False, timestamp=int(time.time()), size=size,
-                          width=None, height=None, decryption_info=decryption_info)
+                          width=None, height=None)


 async def _internal_transfer_to_telegram(client: MautrixTelegramClient, response: ClientResponse
@@ -315,9 +315,9 @@ class ProvisioningAPI(AuthAPI):

        if not user.is_bot:
            return web.json_response([{
-                "id": chat.id,
+                "id": get_peer_id(chat),
                "title": chat.title,
-            } async for chat in user.client.iter_dialogs(ignore_migrated=True, archived=False)])
+            } async for chat in user.client.get_dialogs(ignore_migrated=True, archived=False)])
        else:
            return web.json_response([{
                "id": get_peer_id(chat.peer),
@@ -1,23 +1,5 @@
-# Format: #/name defines a new extras_require group called name
-# Uncommented lines after the group definition insert things into that group.
-
-#/speedups
-cryptg>=0.1,<0.3
-cchardet
-aiodns
-brotli
-
-#/webp_convert
-pillow>=4.3,<8
-
-#/hq_thumbnails
-moviepy>=1,<2
-
-#/metrics
-prometheus_client>=0.6,<0.8
-
-#/postgres
-psycopg2-binary>=2,<3
-
-#/e2be
-matrix-nio[e2e]>=0.9,<0.11
+cryptg
+Pillow
+moviepy
+prometheus_client
+psycopg2-binary
@@ -1,9 +1,9 @@
-SQLAlchemy>=1.2,<2
-alembic>=1,<2
-ruamel.yaml>=0.15.35,<0.17
-python-magic>=0.4,<0.5
-commonmark>=0.8,<0.10
-aiohttp>=3,<4
-mautrix==0.5.0rc2
-telethon>=1.13,<1.15
-telethon-session-sqlalchemy>=0.2.14,<0.3
+aiohttp
+mautrix
+ruamel.yaml
+python-magic
+SQLAlchemy
+alembic
+commonmark
+telethon
+telethon-session-sqlalchemy
@@ -3,21 +3,14 @@ import glob

 from mautrix_telegram.get_version import git_tag, git_revision, version, linkified_version

-with open("requirements.txt") as reqs:
-    install_requires = reqs.read().splitlines()
-
-with open("optional-requirements.txt") as reqs:
-    extras_require = {}
-    current = []
-    for line in reqs.read().splitlines():
-        if line.startswith("#/"):
-            extras_require[line[2:]] = current = []
-        elif not line or line.startswith("#"):
-            continue
-        else:
-            current.append(line)
-
-extras_require["all"] = list({dep for deps in extras_require.values() for dep in deps})
+extras = {
+    "speedups": ["cryptg>=0.1,<0.3", "cchardet", "aiodns", "Brotli"],
+    "webp_convert": ["Pillow>=4.3.0,<7"],
+    "hq_thumbnails": ["moviepy>=1.0,<2.0"],
+    "metrics": ["prometheus_client>=0.6.0,<0.8.0"],
+    "postgres": ["psycopg2-binary>=2,<3"],
+}
+extras["all"] = list({dep for deps in extras.values() for dep in deps})

 try:
    long_desc = open("README.md").read()
@@ -47,8 +40,18 @@ setuptools.setup(

    packages=setuptools.find_packages(),

-    install_requires=install_requires,
-    extras_require=extras_require,
+    install_requires=[
+        "aiohttp>=3.0.1,<4",
+        "mautrix>=0.4.0,<0.5",
+        "SQLAlchemy>=1.2.3,<2",
+        "alembic>=1.0.0,<2",
+        "commonmark>=0.8.1,<0.10",
+        "ruamel.yaml>=0.15.35,<0.17",
+        "python-magic>=0.4.15,<0.5",
+        "telethon>=1.10,<1.11",
+        "telethon-session-sqlalchemy>=0.2.14,<0.3",
+    ],
+    extras_require=extras,
    python_requires="~=3.6",

    setup_requires=["pytest-runner"],
@@ -71,10 +74,9 @@ setuptools.setup(
    """,
    package_data={"mautrix_telegram": [
        "web/public/*.mako", "web/public/*.png", "web/public/*.css",
-        "example-config.yaml",
    ]},
    data_files=[
-        (".", ["alembic.ini"]),
+        (".", ["example-config.yaml", "alembic.ini"]),
        ("alembic", ["alembic/env.py"]),
        ("alembic/versions", glob.glob("alembic/versions/*.py"))
    ],
Author	SHA1	Message	Date
Tulir Asokan	cb9665f9ab	Bump version to 0.7.2	2020-04-04 22:05:01 +03:00
Tulir Asokan	69ffdcfed6	Bump version to 0.7.2rc1	2020-02-08 13:32:25 +02:00
Tulir Asokan	da72c51644	Only leave group chat portals with default puppet. Fixes #418	2020-02-08 13:28:07 +02:00
Tulir Asokan	62efc39eed	Fix ignore_incoming_bot_events check in channels Fixes #417	2020-02-08 13:28:07 +02:00