Implement smarter authservid algorithm

.gitattributes

@@ -2,17 +2,9 @@
 # ensures this even if the user has not set core.autocrlf.
 *  text=auto
 
-# Checkout JavaScript files with LF line endings
-# to prevent `prettier` from reporting errors on Windows.
-*.js eol=lf
-*.jsx eol=lf
-*.ts eol=lf
-*.tsx eol=lf
-*.json eol=lf
-
 # This directory contains email messages verbatim, and changing CRLF to
 # LF will corrupt them.
-test-data/** text=false
+test-data/* text=false
 
 # binary files should be detected by git, however, to be sure, you can add them here explicitly
 *.png  binary

.github/dependabot.yml

@@ -5,5 +5,5 @@ updates:
     schedule:
       interval: "monthly"
     commit-message:
-      prefix: "chore(cargo)"
+      prefix: "cargo"
     open-pull-requests-limit: 50

.github/mergeable.yml

@@ -0,0 +1,26 @@
+version: 2
+mergeable:
+  - when: pull_request.*
+    name: "Changelog check"
+    validate:
+      - do: or
+        validate:
+        - do: description
+          must_include:
+            regex: '#skip-changelog'
+        - do: and
+          validate:
+            - do: dependent
+              changed:
+                file: 'src/**'
+                required: ['CHANGELOG.md']
+            - do: dependent
+              changed:
+                file: 'deltachat-ffi/src/**'
+                required: ['CHANGELOG.md']
+    fail:
+      - do: checks
+        status: 'action_required' 
+        payload:
+          title: Changelog might need an update
+          summary: "Check if CHANGELOG.md needs an update or add #skip-changelog to the PR description."

.github/workflows/ci.yml

@@ -1,61 +1,48 @@
-# GitHub Actions workflow to
-# lint Rust and Python code
-# and run Rust tests, Python tests and async Python tests.
-
 name: Rust CI
 
-# Cancel previously started workflow runs
-# when the branch is updated.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
 on:
   pull_request:
   push:
     branches:
-      - main
+      - master
+      - staging
+      - trying
 
 env:
   RUSTFLAGS: -Dwarnings
-
+   
 jobs:
-  lint_rust:
-    name: Lint Rust
-    runs-on: ubuntu-latest
-    env:
-      RUSTUP_TOOLCHAIN: 1.74.0
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install rustfmt and clippy
-        run: rustup toolchain install $RUSTUP_TOOLCHAIN --profile minimal --component rustfmt --component clippy
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-      - name: Run rustfmt
-        run: cargo fmt --all -- --check
-      - name: Run clippy
-        run: scripts/clippy.sh
-      - name: Check
-        run: cargo check --workspace --all-targets --all-features
 
-  cargo_deny:
-    name: cargo deny
+  fmt:
+    name: Rustfmt
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: EmbarkStudios/cargo-deny-action@v1
+      - uses: actions-rs/toolchain@v1
         with:
-          arguments: --all-features --workspace
-          command: check
-          command-arguments: "-Dwarnings"
+          profile: minimal
+          toolchain: stable
+          override: true
+      - run: rustup component add rustfmt
+      - name: Cache rust cargo artifacts
+        uses: swatinem/rust-cache@v1
+      - run: cargo fmt --all -- --check
 
-  provider_database:
-    name: Check provider database
+  run_clippy:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Check provider database
-        run: scripts/update-provider-database.sh
+      - uses: actions-rs/toolchain@v1
+        with:
+            toolchain: stable
+            components: clippy
+            override: true
+      - name: Cache rust cargo artifacts
+        uses: swatinem/rust-cache@v1
+      - uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --workspace --tests --examples --benches --features repl -- -D warnings
 
   docs:
     name: Rust doc comments
@@ -65,215 +52,110 @@ jobs:
     steps:
       - name: Checkout sources
         uses: actions/checkout@v3
+      - name: Install rust stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          components: rust-docs
+          override: true
       - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
+        uses: swatinem/rust-cache@v1
       - name: Rustdoc
         run: cargo doc --document-private-items --no-deps
 
-  rust_tests:
-    name: Rust tests
+  build_and_test:
+    name: Build and test
     strategy:
       matrix:
         include:
+          # Currently used Rust version, same as in `rust-toolchain` file.
           - os: ubuntu-latest
-            rust: 1.74.0
+            rust: 1.65.0
+            python: 3.9
           - os: windows-latest
-            rust: 1.74.0
-          - os: macos-latest
-            rust: 1.74.0
-
-          # Minimum Supported Rust Version = 1.70.0
-          - os: ubuntu-latest
-            rust: 1.70.0
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install Rust ${{ matrix.rust }}
-        run: rustup toolchain install --profile minimal ${{ matrix.rust }}
-      - run: rustup override set ${{ matrix.rust }}
-
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-
-      - name: Tests
-        env:
-          RUST_BACKTRACE: 1
-        run: cargo test --workspace
-
-      - name: Test cargo vendor
-        run: cargo vendor
-
-  c_library:
-    name: Build C library
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-
-      - name: Build C library
-        run: cargo build -p deltachat_ffi --features jsonrpc
-
-      - name: Upload C library
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.os }}-libdeltachat.a
-          path: target/debug/libdeltachat.a
-          retention-days: 1
-
-  rpc_server:
-    name: Build deltachat-rpc-server
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-
-      - name: Build deltachat-rpc-server
-        run: cargo build -p deltachat-rpc-server
-
-      - name: Upload deltachat-rpc-server
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.os }}-deltachat-rpc-server
-          path: ${{ matrix.os == 'windows-latest' && 'target/debug/deltachat-rpc-server.exe' || 'target/debug/deltachat-rpc-server' }}
-          retention-days: 1
-
-  python_lint:
-    name: Python lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-
-      - name: Install tox
-        run: pip install tox
-
-      - name: Lint Python bindings
-        working-directory: python
-        run: tox -e lint
-
-      - name: Lint deltachat-rpc-client
-        working-directory: deltachat-rpc-client
-        run: tox -e lint
-
-  cffi_python_tests:
-    name: CFFI Python tests
-    needs: ["c_library", "python_lint"]
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          # Currently used Rust version.
-          - os: ubuntu-latest
-            python: 3.12
-          - os: macos-latest
-            python: 3.12
-
-          # PyPy tests
-          - os: ubuntu-latest
-            python: pypy3.10
-          - os: macos-latest
-            python: pypy3.10
+            rust: 1.65.0
+            python: false # Python bindings compilation on Windows is not supported.
 
+          # Minimum Supported Rust Version = 1.61.0
+          #
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
-          # built. Test it with minimum supported Rust version.
+          # built.
           - os: ubuntu-latest
+            rust: 1.61.0
             python: 3.7
-
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v3
+    - uses: actions/checkout@master
 
-      - name: Download libdeltachat.a
-        uses: actions/download-artifact@v3
-        with:
-          name: ${{ matrix.os }}-libdeltachat.a
-          path: target/debug
+    - name: Install ${{ matrix.rust }}
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: ${{ matrix.rust }}
+        override: true
 
-      - name: Install python
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python }}
+    - name: Cache rust cargo artifacts
+      uses: swatinem/rust-cache@v1
 
-      - name: Install tox
-        run: pip install tox
+    - name: check
+      run: cargo check --all --bins --examples --tests --features repl --benches
 
-      - name: Run python tests
-        env:
-          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
-          DCC_RS_TARGET: debug
-          DCC_RS_DEV: ${{ github.workspace }}
-        working-directory: python
-        run: tox -e mypy,doc,py
+    - name: tests
+      run: cargo test --all
 
-  rpc_python_tests:
-    name: JSON-RPC Python tests
-    needs: ["python_lint", "rpc_server"]
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-latest
-            python: 3.12
-          - os: macos-latest
-            python: 3.12
-          - os: windows-latest
-            python: 3.12
+    - name: test cargo vendor
+      run: cargo vendor
 
-          # PyPy tests
-          - os: ubuntu-latest
-            python: pypy3.10
-          - os: macos-latest
-            python: pypy3.10
+    - name: install python
+      if: ${{ matrix.python }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python }}
 
-          # Minimum Supported Python Version = 3.7
-          - os: ubuntu-latest
-            python: 3.7
+    - name: install tox
+      if: ${{ matrix.python }}
+      run: pip install tox
 
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
+    - name: build C library
+      if: ${{ matrix.python }}
+      run: cargo build -p deltachat_ffi --features jsonrpc
 
-      - name: Install python
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python }}
+    - name: run python tests
+      if: ${{ matrix.python }}
+      env:
+        DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+        DCC_RS_TARGET: debug
+        DCC_RS_DEV: ${{ github.workspace }}
+      working-directory: python
+      run: tox -e lint,mypy,doc,py3
 
-      - name: Install tox
-        run: pip install tox
+    - name: build deltachat-rpc-server
+      if: ${{ matrix.python }}
+      run: cargo build -p deltachat-rpc-server
 
-      - name: Download deltachat-rpc-server
-        uses: actions/download-artifact@v3
-        with:
-          name: ${{ matrix.os }}-deltachat-rpc-server
-          path: target/debug
+    - name: add deltachat-rpc-server to path
+      if: ${{ matrix.python }}
+      run: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH
 
-      - name: Make deltachat-rpc-server executable
-        if: ${{ matrix.os != 'windows-latest' }}
-        run: chmod +x target/debug/deltachat-rpc-server
+    - name: run deltachat-rpc-client tests
+      if: ${{ matrix.python }}
+      env:
+        DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+      working-directory: deltachat-rpc-client
+      run: tox -e py3
 
-      - name: Add deltachat-rpc-server to path
-        if: ${{ matrix.os != 'windows-latest' }}
-        run: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH
+    - name: install pypy
+      if: ${{ matrix.python }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: 'pypy${{ matrix.python }}'
 
-      - name: Add deltachat-rpc-server to path
-        if: ${{ matrix.os == 'windows-latest' }}
-        run: |
-          "${{ github.workspace }}/target/debug" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-
-      - name: Run deltachat-rpc-client tests
-        env:
-          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
-        working-directory: deltachat-rpc-client
-        run: tox -e py
+    - name: run pypy tests
+      if: ${{ matrix.python }}
+      env:
+        DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+        DCC_RS_TARGET: debug
+        DCC_RS_DEV: ${{ github.workspace }}
+      working-directory: python
+      run: tox -e pypy3

.github/workflows/deltachat-rpc-server.yml

@@ -1,168 +0,0 @@
-# GitHub Actions workflow
-# to build `deltachat-rpc-server` binaries
-# and upload them to the release.
-#
-# The workflow is automatically triggered on releases.
-# It can also be triggered manually
-# to produce binary artifacts for testing.
-
-name: Build deltachat-rpc-server binaries
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-on:
-  workflow_dispatch:
-  release:
-    types: [published]
-
-jobs:
-  # Build a version statically linked against musl libc
-  # to avoid problems with glibc version incompatibility.
-  build_linux:
-    name: Cross-compile deltachat-rpc-server for x86_64, i686, aarch64 and armv7 Linux
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install ziglang
-        run: pip install wheel ziglang==0.11.0
-
-      - name: Build deltachat-rpc-server binaries
-        run: sh scripts/zig-rpc-server.sh
-
-      - name: Upload dist directory with Linux binaries
-        uses: actions/upload-artifact@v3
-        with:
-          name: linux
-          path: dist/
-          if-no-files-found: error
-
-  build_windows:
-    name: Build deltachat-rpc-server for Windows
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: windows-latest
-            artifact: win32.exe
-            path: deltachat-rpc-server.exe
-            target: i686-pc-windows-msvc
-
-          - os: windows-latest
-            artifact: win64.exe
-            path: deltachat-rpc-server.exe
-            target: x86_64-pc-windows-msvc
-
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup rust target
-        run: rustup target add ${{ matrix.target }}
-
-      - name: Build
-        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.target }} --features vendored
-
-      - name: Upload binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: deltachat-rpc-server-${{ matrix.artifact }}
-          path: target/${{ matrix.target}}/release/${{ matrix.path }}
-          if-no-files-found: error
-
-  build_macos:
-    name: Build deltachat-rpc-server for macOS
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - arch: x86_64
-          - arch: aarch64
-
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup rust target
-        run: rustup target add ${{ matrix.arch }}-apple-darwin
-
-      - name: Build
-        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.arch }}-apple-darwin --features vendored
-
-      - name: Upload binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: deltachat-rpc-server-${{ matrix.arch }}-macos
-          path: target/${{ matrix.arch }}-apple-darwin/release/deltachat-rpc-server
-          if-no-files-found: error
-
-  publish:
-    name: Build wheels and upload binaries to the release
-    needs: ["build_linux", "build_windows", "build_macos"]
-    permissions:
-      contents: write
-    runs-on: "ubuntu-latest"
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Download Linux binaries
-        uses: actions/download-artifact@v3
-        with:
-          name: linux
-          path: dist/
-
-      - name: Download win32 binary
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-win32.exe
-          path: deltachat-rpc-server-win32.exe.d
-
-      - name: Download win64 binary
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-win64.exe
-          path: deltachat-rpc-server-win64.exe.d
-
-      - name: Download macOS binary for x86_64
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-x86_64-macos
-          path: deltachat-rpc-server-x86_64-macos.d
-
-      - name: Download macOS binary for aarch64
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-aarch64-macos
-          path: deltachat-rpc-server-aarch64-macos.d
-
-      - name: Flatten dist/ directory
-        run: |
-          mv deltachat-rpc-server-win32.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win32.exe
-          mv deltachat-rpc-server-win64.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win64.exe
-          mv deltachat-rpc-server-x86_64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-macos
-          mv deltachat-rpc-server-aarch64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-macos
-
-      # Python 3.11 is needed for tomllib used in scripts/wheel-rpc-server.py
-      - name: Install python 3.12
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.12
-
-      - name: Install wheel
-        run: pip install wheel
-
-      - name: Build deltachat-rpc-server Python wheels and source package
-        run: scripts/wheel-rpc-server.py
-
-      - name: List downloaded artifacts
-        run: ls -l dist/
-
-      - name: Upload binaries to the GitHub release
-        env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-        run: |
-          gh release upload ${{ github.ref_name }} \
-            --repo ${{ github.repository }} \
-            dist/*

.github/workflows/dependabot.yml

@@ -1,6 +1,3 @@
-# GitHub Actions workflow
-# to automatically approve PRs made by Dependabot.
-
 name: Dependabot auto-approve
 on: pull_request
 

.github/workflows/jsonrpc-client-npm-package.yml

@@ -1,28 +1,29 @@
-name: "jsonrpc js client build"
+name: 'jsonrpc js client build'
 on:
   pull_request:
   push:
     tags:
-      - "*"
-      - "!py-*"
+    - '*'
+    - '!py-*'
+
 
 jobs:
   pack-module:
-    name: "Package @deltachat/jsonrpc-client and upload to download.delta.chat"
-    runs-on: ubuntu-20.04
+    name: 'Package @deltachat/jsonrpc-client and upload to download.delta.chat'
+    runs-on: ubuntu-18.04
     steps:
-      - name: Install tree
+      - name: install tree
         run: sudo apt install tree
       - name: Checkout
         uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: "18"
-      - name: Get tag
+          node-version: '16'
+      - name: get tag
         id: tag
         uses: dawidd6/action-get-tag@v1
         continue-on-error: true
-      - name: Get Pull Request ID
+      - name: Get Pullrequest ID
         id: prepare
         run: |
           tag=${{ steps.tag.outputs.tag }}
@@ -37,13 +38,14 @@ jobs:
           npm --version
           node --version
           echo $DELTACHAT_JSONRPC_TAR_GZ
-      - name: Install dependencies without running scripts
-        working-directory: deltachat-jsonrpc/typescript
-        run: npm install --ignore-scripts
-      - name: Package
-        shell: bash
-        working-directory: deltachat-jsonrpc/typescript
+      - name: install dependencies without running scripts
         run: |
+          cd deltachat-jsonrpc/typescript
+          npm install --ignore-scripts
+      - name: package
+        shell: bash
+        run: |
+          cd deltachat-jsonrpc/typescript
           npm run build
           npm pack .
           ls -lah
@@ -63,13 +65,13 @@ jobs:
           chmod 600 __TEMP_INPUT_KEY_FILE
           scp -o StrictHostKeyChecking=no -v -i __TEMP_INPUT_KEY_FILE -P "22" -r deltachat-jsonrpc/typescript/$DELTACHAT_JSONRPC_TAR_GZ "${{ secrets.USERNAME }}"@"download.delta.chat":"/var/www/html/download/node/preview/"
         continue-on-error: true
-      - name: Post links to details
+      - name: "Post links to details"
         if: steps.upload-preview.outcome == 'success'
         run: node ./node/scripts/postLinksToDetails.js
         env:
-          URL: preview/${{ env.DELTACHAT_JSONRPC_TAR_GZ }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          MSG_CONTEXT: Download the deltachat-jsonrpc-client.tgz
+         URL: preview/${{ env.DELTACHAT_JSONRPC_TAR_GZ }}
+         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+         MSG_CONTEXT: Download the deltachat-jsonrpc-client.tgz
       # Upload to download.delta.chat/node/
       - name: Upload deltachat-jsonrpc-client build to download.delta.chat/node/
         if: ${{ steps.tag.outputs.tag }}

.github/workflows/jsonrpc.yml

@@ -2,9 +2,9 @@ name: JSON-RPC API Test
 
 on:
   push:
-    branches: [main]
+    branches: [master]
   pull_request:
-    branches: [main]
+    branches: [master]
 
 env:
   CARGO_TERM_COLOR: always
@@ -15,26 +15,32 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Use Node.js 18.x
+      - name: Use Node.js 16.x
         uses: actions/setup-node@v3
         with:
-          node-version: 18.x
+          node-version: 16.x
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
       - name: Add Rust cache
-        uses: Swatinem/rust-cache@v2
+        uses: Swatinem/rust-cache@v1.3.0
       - name: npm install
-        working-directory: deltachat-jsonrpc/typescript
-        run: npm install
+        run: |
+          cd deltachat-jsonrpc/typescript
+          npm install
       - name: Build TypeScript, run Rust tests, generate bindings
-        working-directory: deltachat-jsonrpc/typescript
-        run: npm run build
+        run: |
+          cd deltachat-jsonrpc/typescript
+          npm run build
       - name: Run integration tests
-        working-directory: deltachat-jsonrpc/typescript
-        run: npm run test
+        run: |
+          cd deltachat-jsonrpc/typescript
+          npm run test
         env:
-          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
-      - name: make sure websocket server version still builds
-        working-directory: deltachat-jsonrpc
-        run: cargo build --bin deltachat-jsonrpc-server --features webserver
+          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
       - name: Run linter
-        working-directory: deltachat-jsonrpc/typescript
-        run: npm run prettier:check
+        run: |
+          cd deltachat-jsonrpc/typescript
+          npm run prettier:check

.github/workflows/node-delete-preview.yml

@@ -0,0 +1,32 @@
+# documentation: https://github.com/deltachat/sysadmin/tree/master/download.delta.chat
+name: Delete node PR previews
+
+on:
+  pull_request:
+    types: [closed]
+
+jobs:
+  delete:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Get Pullrequest ID
+      id: getid
+      run: |
+        export PULLREQUEST_ID=$(jq .number < $GITHUB_EVENT_PATH)
+        echo "prid=$PULLREQUEST_ID" >> $GITHUB_OUTPUT
+    - name: Renaming
+      run: |
+        # create empty file to copy it over the outdated deliverable on download.delta.chat
+        echo "This preview build is outdated and has been removed." > empty
+        cp empty deltachat-node-${{ steps.getid.outputs.prid }}.tar.gz
+    - name: Replace builds with dummy files
+      uses: horochx/deploy-via-scp@v1.0.1
+      with:
+        user: ${{ secrets.USERNAME }}
+        key: ${{ secrets.SSH_KEY }}
+        host: "download.delta.chat"
+        port: 22
+        local: "deltachat-node-${{ steps.getid.outputs.prid }}.tar.gz"
+        remote: "/var/www/html/download/node/preview/"

.github/workflows/node-docs.yml

@@ -1,39 +1,34 @@
-# GitHub Actions workflow to build
-# Node.js bindings documentation
-# and upload it to the web server.
-# Built documentation is available at <https://js.delta.chat/>
-
 name: Generate & upload node.js documentation
 
 on:
   push:
     branches:
-      - main
+      - master
 
 jobs:
   generate:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+    - uses: actions/checkout@v3
 
-      - name: Use Node.js 18.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18.x
+    - name: Use Node.js 16.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 16.x
 
-      - name: npm install and generate documentation
-        working-directory: node
-        run: |
-          npm i --ignore-scripts
-          npx typedoc
-          mv docs js
+    - name: npm install and generate documentation
+      run: |
+        cd node
+        npm i --ignore-scripts
+        npx typedoc
+        mv docs js
 
-      - name: Upload
-        uses: horochx/deploy-via-scp@v1.0.1
-        with:
-          user: ${{ secrets.USERNAME }}
-          key: ${{ secrets.KEY }}
-          host: "delta.chat"
-          port: 22
-          local: "node/js"
-          remote: "/var/www/html/"
+    - name: Upload
+      uses: horochx/deploy-via-scp@v1.0.1
+      with:
+        user: ${{ secrets.USERNAME }}
+        key: ${{ secrets.KEY }}
+        host: "delta.chat"
+        port: 22
+        local: "node/js"
+        remote: "/var/www/html/"

.github/workflows/node-package.yml

@@ -1,24 +1,25 @@
-name: "node.js build"
+name: 'node.js build'
 on:
   pull_request:
   push:
     tags:
-      - "*"
-      - "!py-*"
+    - '*'
+    - '!py-*'
+
 
 jobs:
   prebuild:
-    name: Prebuild
+    name: 'prebuild'
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, windows-latest]
+        os: [ubuntu-18.04, macos-latest, windows-latest]
     steps:
       - name: Checkout
         uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: "18"
+          node-version: '16'
       - name: System info
         run: |
           rustc -vV
@@ -46,12 +47,13 @@ jobs:
 
       - name: Install dependencies & build
         if: steps.cache.outputs.cache-hit != 'true'
-        working-directory: node
-        run: npm install --verbose
+        run: |
+          cd node
+          npm install --verbose
 
       - name: Build Prebuild
-        working-directory: node
         run: |
+          cd node
           npm run prebuildify
           tar -zcvf "${{ matrix.os }}.tar.gz" -C prebuilds .
 
@@ -61,92 +63,23 @@ jobs:
           name: ${{ matrix.os }}
           path: node/${{ matrix.os }}.tar.gz
 
-  prebuild-linux:
-    name: Prebuild Linux
-    runs-on: ubuntu-latest
-
-    # Build Linux prebuilds inside a container with old glibc for backwards compatibility.
-    # Debian 10 contained glibc 2.28: https://packages.debian.org/buster/libc6
-    container: debian:10
-    steps:
-      # Working directory is owned by 1001:1001 by default.
-      # Change it to our user.
-      - name: Change working directory owner
-        run: chown root:root .
-
-      - name: Checkout
-        uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: "18"
-      - run: apt-get update
-
-      # Python is needed for node-gyp
-      - name: Install curl, python and compilers
-        run: apt-get install -y curl build-essential python3
-      - name: Install Rust
-        run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
-      - name: System info
-        run: |
-          rustc -vV
-          rustup -vV
-          cargo -vV
-          npm --version
-          node --version
-
-      - name: Cache node modules
-        uses: actions/cache@v3
-        with:
-          path: |
-            ${{ env.APPDATA }}/npm-cache
-            ~/.npm
-          key: ${{ matrix.os }}-node-${{ hashFiles('**/package.json') }}
-
-      - name: Cache cargo index
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo/registry/
-            ~/.cargo/git
-            target
-          key: ${{ matrix.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}-2
-
-      - name: Install dependencies & build
-        if: steps.cache.outputs.cache-hit != 'true'
-        working-directory: node
-        run: npm install --verbose
-
-      - name: Build Prebuild
-        working-directory: node
-        run: |
-          npm run prebuildify
-          tar -zcvf "linux.tar.gz" -C prebuilds .
-
-      - name: Upload Prebuild
-        uses: actions/upload-artifact@v3
-        with:
-          name: linux
-          path: node/linux.tar.gz
-
   pack-module:
-    needs: [prebuild, prebuild-linux]
-    name: Package deltachat-node and upload to download.delta.chat
-    runs-on: ubuntu-latest
+    needs: prebuild
+    name: 'Package deltachat-node and upload to download.delta.chat'
+    runs-on: ubuntu-18.04
     steps:
-      - name: Install tree
+      - name: install tree
         run: sudo apt install tree
       - name: Checkout
         uses: actions/checkout@v3
       - uses: actions/setup-node@v2
         with:
-          node-version: "18"
-      - name: Get tag
+          node-version: '16'
+      - name: get tag
         id: tag
         uses: dawidd6/action-get-tag@v1
         continue-on-error: true
-      - name: Get Pull Request ID
+      - name: Get Pullrequest ID
         id: prepare
         run: |
           tag=${{ steps.tag.outputs.tag }}
@@ -164,43 +97,43 @@ jobs:
           npm --version
           node --version
           echo $DELTACHAT_NODE_TAR_GZ
-      - name: Download Linux prebuild
+      - name: Download ubuntu prebuild
         uses: actions/download-artifact@v1
         with:
-          name: linux
-      - name: Download macOS prebuild
+          name: ubuntu-18.04
+      - name: Download macos prebuild
         uses: actions/download-artifact@v1
         with:
           name: macos-latest
-      - name: Download Windows prebuild
+      - name: Download windows prebuild
         uses: actions/download-artifact@v1
         with:
           name: windows-latest
       - shell: bash
         run: |
           mkdir node/prebuilds
-          tar -xvzf linux/linux.tar.gz -C node/prebuilds
+          tar -xvzf ubuntu-18.04/ubuntu-18.04.tar.gz -C node/prebuilds
           tar -xvzf macos-latest/macos-latest.tar.gz -C node/prebuilds
           tar -xvzf windows-latest/windows-latest.tar.gz -C node/prebuilds
           tree node/prebuilds
-          rm -rf linux macos-latest windows-latest
-      - name: Install dependencies without running scripts
+          rm -rf ubuntu-18.04 macos-latest windows-latest
+      - name: install dependencies without running scripts
         run: |
           npm install --ignore-scripts
-      - name: Build constants
+      - name: build constants
         run: |
           npm run build:core:constants
-      - name: Build TypeScript part
+      - name: build typescript part
         run: |
           npm run build:bindings:ts
-      - name: Package
+      - name: package
         shell: bash
         run: |
           mv node/README.md README.md
           npm pack .
           ls -lah
           mv $(find deltachat-node-*) $DELTACHAT_NODE_TAR_GZ
-      - name: Upload prebuild
+      - name: Upload Prebuild
         uses: actions/upload-artifact@v3
         with:
           name: deltachat-node.tgz
@@ -215,12 +148,12 @@ jobs:
           chmod 600 __TEMP_INPUT_KEY_FILE
           scp -o StrictHostKeyChecking=no -v -i __TEMP_INPUT_KEY_FILE -P "22" -r $DELTACHAT_NODE_TAR_GZ "${{ secrets.USERNAME }}"@"download.delta.chat":"/var/www/html/download/node/preview/"
         continue-on-error: true
-      - name: Post links to details
+      - name: "Post links to details"
         if: steps.upload-preview.outcome == 'success'
         run: node ./node/scripts/postLinksToDetails.js
         env:
-          URL: preview/${{ env.DELTACHAT_NODE_TAR_GZ }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+         URL: preview/${{ env.DELTACHAT_NODE_TAR_GZ }}
+         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       # Upload to download.delta.chat/node/
       - name: Upload deltachat-node build to download.delta.chat/node/
         if: ${{ steps.tag.outputs.tag }}

.github/workflows/node-tests.yml

@@ -1,33 +1,25 @@
-# GitHub Actions workflow
-# to test Node.js bindings.
-
-name: "node.js tests"
-
-# Cancel previously started workflow runs
-# when the branch is updated.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
+name: 'node.js tests'
 on:
   pull_request:
   push:
     branches:
-      - main
+      - master
+      - staging
+      - trying
 
 jobs:
   tests:
-    name: Tests
+    name: 'tests'
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-18.04, macos-latest, windows-latest]
     steps:
       - name: Checkout
         uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: "18"
+          node-version: '16'
       - name: System info
         run: |
           rustc -vV
@@ -55,13 +47,23 @@ jobs:
 
       - name: Install dependencies & build
         if: steps.cache.outputs.cache-hit != 'true'
-        working-directory: node
-        run: npm install --verbose
+        run: |
+          cd node
+          npm install --verbose
 
       - name: Test
         timeout-minutes: 10
-        working-directory: node
-        run: npm run test
+        if: runner.os != 'Windows'
+        run: |
+          cd node
+          npm run test
         env:
-          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
-          NODE_OPTIONS: "--force-node-api-uncaught-exceptions-policy=true"
+          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+      - name: Run tests on Windows, except lint
+        timeout-minutes: 10
+        if: runner.os == 'Windows'
+        run: |
+          cd node
+          npm run test:mocha
+        env:
+          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}

.github/workflows/repl.yml

@@ -1,5 +1,4 @@
-# Manually triggered GitHub Actions workflow
-# to build a Windows repl.exe which users can
+# Manually triggered action to build a Windows repl.exe which users can
 # download to debug complex bugs.
 
 name: Build Windows REPL .exe
@@ -12,13 +11,19 @@ jobs:
     name: Build REPL example
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v3
+    - uses: actions/checkout@v3
 
-      - name: Build
-        run: cargo build -p deltachat-repl --features vendored
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: 1.50.0
+        override: true
 
-      - name: Upload binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: repl.exe
-          path: "target/debug/deltachat-repl.exe"
+    - name: build
+      run: cargo build --example repl --features repl,vendored
+
+    - name: Upload binary
+      uses: actions/upload-artifact@v3
+      with:
+        name: repl.exe
+        path: 'target/debug/examples/repl.exe'

.github/workflows/upload-docs.yml

@@ -3,22 +3,26 @@ name: Build & Deploy Documentation on rs.delta.chat
 on:
   push:
     branches:
-      - main
+      - master
+      - docs-gh-action
 
 jobs:
   build:
+
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
-      - name: Build the documentation with cargo
-        run: |
-          cargo doc --package deltachat --no-deps --document-private-items
-      - name: Upload to rs.delta.chat
-        uses: up9cloud/action-rsync@v1.3
-        env:
-          USER: ${{ secrets.USERNAME }}
-          KEY: ${{ secrets.KEY }}
-          HOST: "delta.chat"
-          SOURCE: "target/doc"
-          TARGET: "/var/www/html/rs/"
+    - uses: actions/checkout@v3
+    - uses: actions-rs/toolchain@v1
+    - name: Build the documentation with cargo
+      run: |
+        cargo doc --package deltachat --no-deps
+    - name: Upload to rs.delta.chat
+      uses: up9cloud/action-rsync@v1.3
+      env:
+        USER: ${{ secrets.USERNAME }}
+        KEY: ${{ secrets.KEY }}
+        HOST: "delta.chat"
+        SOURCE: "target/doc"
+        TARGET: "/var/www/html/rs/"
+

.github/workflows/upload-ffi-docs.yml

@@ -1,28 +1,28 @@
-# GitHub Actions workflow
-# to build `deltachat_fii` crate documentation
-# and upload it to <https://cffi.delta.chat/>
-
 name: Build & Deploy Documentation on cffi.delta.chat
 
 on:
   push:
     branches:
-      - main
+      - master
+      - docs-gh-action
 
 jobs:
   build:
+
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
-      - name: Build the documentation with cargo
-        run: |
-          cargo doc --package deltachat_ffi --no-deps
-      - name: Upload to cffi.delta.chat
-        uses: up9cloud/action-rsync@v1.3
-        env:
-          USER: ${{ secrets.USERNAME }}
-          KEY: ${{ secrets.KEY }}
-          HOST: "delta.chat"
-          SOURCE: "target/doc"
-          TARGET: "/var/www/html/cffi/"
+    - uses: actions/checkout@v3
+    - uses: actions-rs/toolchain@v1
+    - name: Build the documentation with cargo
+      run: |
+        cargo doc --package deltachat_ffi --no-deps
+    - name: Upload to cffi.delta.chat
+      uses: up9cloud/action-rsync@v1.3
+      env:
+        USER: ${{ secrets.USERNAME }}
+        KEY: ${{ secrets.KEY }}
+        HOST: "delta.chat"
+        SOURCE: "target/doc"
+        TARGET: "/var/www/html/cffi/"
+

.gitignore

@@ -1,7 +1,6 @@
 /target
 **/*.rs.bk
 /build
-/dist
 
 # ignore vi temporaries
 *~
@@ -19,9 +18,6 @@ python/.eggs
 __pycache__
 python/src/deltachat/capi*.so
 python/.venv/
-python/venv/
-venv/
-env/
 
 python/liveconfig*
 

CONTRIBUTING.md

@@ -1,120 +0,0 @@
-# Contributing guidelines
-
-## Reporting bugs
-
-If you found a bug, [report it on GitHub](https://github.com/deltachat/deltachat-core-rust/issues).
-If the bug you found is specific to
-[Android](https://github.com/deltachat/deltachat-android/issues),
-[iOS](https://github.com/deltachat/deltachat-ios/issues) or
-[Desktop](https://github.com/deltachat/deltachat-desktop/issues),
-report it to the corresponding repository.
-
-## Proposing features
-
-If you have a feature request, create a new topic on the [forum](https://support.delta.chat/).
-
-## Contributing code
-
-If you want to contribute a code, [open a Pull Request](https://github.com/deltachat/deltachat-core-rust/pulls).
-
-If you have write access to the repository,
-push a branch named `<username>/<feature>`
-so it is clear who is responsible for the branch,
-and open a PR proposing to merge the change.
-Otherwise fork the repository and create a branch in your fork.
-
-You can find the list of good first issues
-and a link to this guide
-on the contributing page: <https://github.com/deltachat/deltachat-core-rust/contribute>
-
-### Coding conventions
-
-We format the code using `rustfmt`. Run `cargo fmt` prior to committing the code.
-Run `scripts/clippy.sh` to check the code for common mistakes with [Clippy].
-
-Commit messages follow the [Conventional Commits] notation.
-We use [git-cliff] to generate the changelog from commit messages before the release.
-
-With **`git cliff --unreleased`**, you can check how the changelog entry for your commit will look.
-
-The following prefix types are used:
-- `feat`: Features, e.g. "feat: Pause IO for BackupProvider". If you are unsure what's the category of your commit, you can often just use `feat`.
-- `fix`: Bug fixes, e.g. "fix: delete `smtp` rows when message sending is cancelled"
-- `api`: API changes, e.g. "api(rust): add `get_msg_read_receipts(context, msg_id)`"
-- `refactor`: Refactorings, e.g. "refactor: iterate over `msg_ids` without `.iter()`"
-- `perf`: Performance improvements, e.g. "perf: improve SQLite performance with `PRAGMA synchronous=normal`"
-- `test`: Test changes and improvements to the testing framework.
-- `build`: Build system and tool configuration changes, e.g. "build(git-cliff): put "ci" commits into "CI" section of changelog"
-- `ci`: CI configuration changes, e.g. "ci: limit artifact retention time for `libdeltachat.a` to 1 day"
-- `docs`: Documentation changes, e.g. "docs: add contributing guidelines"
-- `chore`: miscellaneous tasks, e.g. "chore: add `.DS_Store` to `.gitignore`"
-
-Release preparation commits are marked as "chore(release): prepare for vX.Y.Z".
-
-If you intend to squash merge the PR from the web interface,
-make sure the PR title follows the conventional commits notation
-as it will end up being a commit title.
-Otherwise make sure each commit title follows the conventional commit notation.
-
-#### Breaking Changes
-
-Use a `!` to mark breaking changes, e.g. "api!: Remove `dc_chat_can_send`".
-
-Alternatively, breaking changes can go into the commit description, e.g.:
-
-```
-fix: Fix race condition and db corruption when a message was received during backup
-
-BREAKING CHANGE: You have to call `dc_stop_io()`/`dc_start_io()` before/after `dc_imex(DC_IMEX_EXPORT_BACKUP)`
-```
-
-#### Multiple Changes in one PR
-
-If you have multiple changes in one PR, create multiple conventional commits, and then do a rebase merge. Otherwise, you should usually do a squash merge.
-
-[Clippy]: https://doc.rust-lang.org/clippy/
-[Conventional Commits]: https://www.conventionalcommits.org/
-[git-cliff]: https://git-cliff.org/
-
-### Errors
-
-Delta Chat core mostly uses [`anyhow`](https://docs.rs/anyhow/) errors.
-When using [`Context`](https://docs.rs/anyhow/latest/anyhow/trait.Context.html),
-capitalize it but do not add a full stop as the contexts will be separated by `:`.
-For example:
-```
-.with_context(|| format!("Unable to trash message {msg_id}"))
-```
-
-All errors should be handled in one of these ways:
-- With `if let Err() =` (incl. logging them into `warn!()`/`err!()`).
-- With `.log_err().ok()`.
-- Bubbled up with `?`.
-
-### Logging
-
-For logging, use `info!`, `warn!` and `error!` macros.
-Log messages should be capitalized and have a full stop in the end. For example:
-```
-info!(context, "Ignoring addition of {added_addr:?} to {chat_id}.");
-```
-
-Format anyhow errors with `{:#}` to print all the contexts like this:
-```
-error!(context, "Failed to set selfavatar timestamp: {err:#}.");
-```
-
-### Reviewing
-
-Once a PR has an approval and passes CI, it can be merged.
-
-PRs from a branch created in the main repository, i.e. authored by those who have write access, are merged by their authors.
-This is to ensure that PRs are merged as intended by the author,
-e.g. as a squash merge, by rebasing from the web interface or manually from the command line.
-
-If you do not have access to the repository and created a PR from a fork,
-ask the maintainers to merge the PR and say how it should be merged.
-
-## Other ways to contribute
-
-For other ways to contribute, refer to the [website](https://delta.chat/en/contribute).

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "deltachat"
-version = "1.131.5"
+version = "1.103.0"
+authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.70"
+rust-version = "1.61"
 
 [profile.dev]
 debug = 0
@@ -13,110 +14,106 @@ opt-level = 1
 [profile.test]
 opt-level = 0
 
-# Always optimize dependencies.
-# This does not apply to crates in the workspace.
-# <https://doc.rust-lang.org/cargo/reference/profiles.html#overrides>
-[profile.dev.package."*"]
-opt-level = "z"
-
 [profile.release]
 lto = true
 panic = 'abort'
-opt-level = "z"
-codegen-units = 1
-strip = true
 
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
-format-flowed = { path = "./format-flowed" }
-ratelimit = { path = "./deltachat-ratelimit" }
 
+ansi_term = { version = "0.12.1", optional = true }
 anyhow = "1"
-async-channel = "2.0.0"
-async-imap = { version = "0.9.1", default-features = false, features = ["runtime-tokio"] }
-async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
-async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
-async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
+async-imap = { git = "https://github.com/async-email/async-imap", branch = "master", default-features = false, features = ["runtime-tokio"] }
+async-native-tls = { version = "0.4", default-features = false, features = ["runtime-tokio"] }
+async-smtp = { version = "0.5", default-features = false, features = ["smtp-transport", "socks5", "runtime-tokio"] }
+trust-dns-resolver = "0.22"
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
+tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
 backtrace = "0.3"
-base64 = "0.21"
-brotli = { version = "3.4", default-features=false, features = ["std"] }
+base64 = "0.13"
+bitflags = "1.3"
 chrono = { version = "0.4", default-features=false, features = ["clock", "std"] }
+dirs = { version = "4", optional=true }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch = "master" }
 escaper = "0.1"
-fast-socks5 = "0.8"
-fd-lock = "3.0.11"
 futures = "0.3"
-futures-lite = "2.0.0"
 hex = "0.4.0"
-hickory-resolver = "0.24"
-humansize = "2"
-image = { version = "0.24.7", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
-iroh = { git = "https://github.com/deltachat/iroh", branch = "0.4-update-quic", default-features = false }
+image = { version = "0.24.5", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"
-mailparse = "0.14"
-mime = "0.3.17"
-num_cpus = "1.16"
-num-derive = "0.4"
+log = {version = "0.4.16", optional = true }
+mailparse = "0.13"
+native-tls = "0.2"
+num_cpus = "1.14"
+num-derive = "0.3"
 num-traits = "0.2"
-once_cell = "1.18.0"
-percent-encoding = "2.3"
-parking_lot = "0.12"
-pgp = { version = "0.10", default-features = false }
-pin-project = "1"
-pretty_env_logger = { version = "0.5", optional = true }
-qrcodegen = "1.7.0"
-quick-xml = "0.31"
+once_cell = "1.16.0"
+percent-encoding = "2.2"
+pgp = { version = "0.9", default-features = false }
+pretty_env_logger = { version = "0.4", optional = true }
+quick-xml = "0.23"
+r2d2 = "0.8"
+r2d2_sqlite = "0.20"
 rand = "0.8"
-regex = "1.9"
-reqwest = { version = "0.11.20", features = ["json"] }
-rusqlite = { version = "0.30", features = ["sqlcipher"] }
+regex = "1.7"
+rusqlite = { version = "0.27", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
-sanitize-filename = "0.5"
+rustyline = { version = "10", optional = true }
+sanitize-filename = "0.4"
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10"
 sha2 = "0.10"
 smallvec = "1"
-strum = "0.25"
-strum_macros = "0.25"
-tagger = "4.3.4"
-textwrap = "0.16.0"
+strum = "0.24"
+strum_macros = "0.24"
 thiserror = "1"
-tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
-tokio-io-timeout = "1.2.0"
-tokio-stream = { version = "0.1.14", features = ["fs"] }
-tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
-tokio-util = "0.7.9"
-toml = "0.8"
+toml = "0.5"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }
+fast-socks5 = "0.8"
+humansize = "2"
+qrcodegen = "1.7.0"
+tagger = "4.3.4"
+textwrap = "0.16.0"
+async-channel = "1.8.0"
+futures-lite = "1.12.0"
+tokio-stream = { version = "0.1.11", features = ["fs"] }
+tokio-io-timeout = "1.2.0"
+reqwest = { version = "0.11.13", features = ["json"] }
+async_zip = { version = "0.0.9", default-features = false, features = ["deflate"] }
 
 [dev-dependencies]
 ansi_term = "0.12.0"
-criterion = { version = "0.5.1", features = ["async_tokio"] }
-futures-lite = "2.0.0"
+criterion = { version = "0.4.0", features = ["async_tokio"] }
+futures-lite = "1.12"
 log = "0.4"
-pretty_env_logger = "0.5"
+pretty_env_logger = "0.4"
 proptest = { version = "1", default-features = false, features = ["std"] }
 tempfile = "3"
-testdir = "0.8.0"
 tokio = { version = "1", features = ["parking_lot", "rt-multi-thread", "macros"] }
-pretty_assertions = "1.3.0"
 
 [workspace]
 members = [
   "deltachat-ffi",
   "deltachat_derive",
   "deltachat-jsonrpc",
-  "deltachat-rpc-server",
-  "deltachat-ratelimit",
-  "deltachat-repl",
-  "format-flowed",
+  "deltachat-rpc-server"
 ]
 
+[[example]]
+name = "simple"
+path = "examples/simple.rs"
+required-features = ["repl"]
+
+[[example]]
+name = "repl"
+path = "examples/repl/main.rs"
+required-features = ["repl"]
+
+
 [[bench]]
 name = "create_account"
 harness = false
@@ -141,15 +138,14 @@ harness = false
 name = "get_chatlist"
 harness = false
 
-[[bench]]
-name = "send_events"
-harness = false
-
 [features]
 default = ["vendored"]
 internals = []
+repl = ["internals", "rustyline", "log", "pretty_env_logger", "ansi_term", "dirs"]
 vendored = [
   "async-native-tls/vendored",
+  "async-smtp/native-tls-vendored",
   "rusqlite/bundled-sqlcipher-vendored-openssl",
   "reqwest/native-tls-vendored"
 ]
+nightly = ["pgp/nightly"]

LICENSE

@@ -361,7 +361,7 @@ Exhibit A - Source Code Form License Notice
 
   This Source Code Form is subject to the terms of the Mozilla Public
   License, v. 2.0. If a copy of the MPL was not distributed with this
-  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 If it is not possible or desirable to put the notice in a particular
 file, then You may include the notice in a location (such as a LICENSE

README.md

@@ -1,16 +1,8 @@
-<p align="center">
-  <img alt="Delta Chat Logo" height="200px" src="https://raw.githubusercontent.com/deltachat/deltachat-pages/master/assets/blog/rust-delta.png">
-</p>
+# Delta Chat Rust
 
-<p align="center">
-  <a href="https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml">
-    <img alt="Rust CI" src="https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml/badge.svg">
-  </a>
-</p>
+> Deltachat-core written in Rust 
 
-<p align="center">
-The core library for Delta Chat, written in Rust
-</p>
+[![Rust CI](https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml/badge.svg)](https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml)
 
 ## Installing Rust and Cargo
 
@@ -27,19 +19,10 @@ $ curl https://sh.rustup.rs -sSf | sh
 Compile and run Delta Chat Core command line utility, using `cargo`:
 
 ```
-$ RUST_LOG=deltachat_repl=info cargo run -p deltachat-repl -- ~/deltachat-db
+$ RUST_LOG=repl=info cargo run --example repl --features repl -- ~/deltachat-db
 ```
 where ~/deltachat-db is the database file. Delta Chat will create it if it does not exist.
 
-Optionally, install `deltachat-repl` binary with
-```
-$ cargo install --path deltachat-repl/
-```
-and run as
-```
-$ deltachat-repl ~/deltachat-db
-```
-
 Configure your account (if not already configured):
 
 ```
@@ -121,7 +104,7 @@ $ cargo build -p deltachat_ffi --release
 
 - `DCC_MIME_DEBUG`: if set outgoing and incoming message will be printed 
 
-- `RUST_LOG=deltachat_repl=info,async_imap=trace,async_smtp=trace`: enable IMAP and
+- `RUST_LOG=repl=info,async_imap=trace,async_smtp=trace`: enable IMAP and
 SMTP tracing in addition to info messages.
 
 ### Expensive tests
@@ -132,29 +115,6 @@ use the `--ignored` argument to the test binary (not to cargo itself):
 $ cargo test -- --ignored
 ```
 
-### Fuzzing
-
-Install [`cargo-bolero`](https://github.com/camshaft/bolero) with
-```sh
-$ cargo install cargo-bolero
-```
-
-Run fuzzing tests with
-```sh
-$ cd fuzz
-$ cargo bolero test fuzz_mailparse --release=false -s NONE
-```
-
-Corpus is created at `fuzz/fuzz_targets/corpus`,
-you can add initial inputs there.
-For `fuzz_mailparse` target corpus can be populated with
-`../test-data/message/*.eml`.
-
-To run with AFL instead of libFuzzer:
-```sh
-$ cargo bolero test fuzz_format_flowed --release=false -e afl -s NONE
-```
-
 ## Features
 
 - `vendored`: When using Openssl for TLS, this bundles a vendored version.
@@ -175,12 +135,10 @@ Language bindings are available for:
 
 - **C** \[[📂 source](./deltachat-ffi) | [📚 docs](https://c.delta.chat)\]
 - **Node.js** 
-  - over cffi: \[[📂 source](./node) | [📦 npm](https://www.npmjs.com/package/deltachat-node) | [📚 docs](https://js.delta.chat)\]
-  - over jsonrpc built with napi.rs (experimental): \[[📂 source](https://github.com/deltachat/napi-jsonrpc) | [📦 npm](https://www.npmjs.com/package/@deltachat/napi-jsonrpc)\]
+  - over cffi (legacy): \[[📂 source](./node) | [📦 npm](https://www.npmjs.com/package/deltachat-node) | [📚 docs](https://js.delta.chat)\]
+  - over jsonrpc built with napi.rs: \[[📂 source](https://github.com/deltachat/napi-jsonrpc) | [📦 npm](https://www.npmjs.com/package/@deltachat/napi-jsonrpc)\]
 - **Python** \[[📂 source](./python) | [📦 pypi](https://pypi.org/project/deltachat) | [📚 docs](https://py.delta.chat)\]
-- **Go**
-  - over jsonrpc: \[[📂 source](https://github.com/deltachat/deltachat-rpc-client-go/)\]
-  - over cffi[^1]: \[[📂 source](https://github.com/deltachat/go-deltachat/)\]
+- **Go**[^1] \[[📂 source](https://github.com/deltachat/go-deltachat/)\]
 - **Free Pascal**[^1] \[[📂 source](https://github.com/deltachat/deltachat-fp/)\]
 - **Java** and **Swift** (contained in the Android/iOS repos)
 

RELEASE.md

@@ -1,21 +0,0 @@
-# Releasing a new version of DeltaChat core
-
-For example, to release version 1.116.0 of the core, do the following steps.
-
-1. Resolve all [blocker issues](https://github.com/deltachat/deltachat-core-rust/labels/blocker).
-
-2. Run `npm run build:core:constants` in the root of the repository
-   and commit generated `node/constants.js`, `node/events.js` and `node/lib/constants.js`.
-
-3. Update the changelog: `git cliff --unreleased --tag 1.116.0 --prepend CHANGELOG.md` or `git cliff -u -t 1.116.0 -p CHANGELOG.md`.
-
-4. Update the version by running `scripts/set_core_version.py 1.116.0`.
-
-5. Commit the changes as `chore(release): prepare for 1.116.0`.
-   Optionally, use a separate branch like `prep-1.116.0` for this commit and open a PR for review.
-
-6. Tag the release: `git tag -a v1.116.0`.
-
-7. Push the release tag: `git push origin v1.116.0`.
-
-8. Create a GitHub release: `gh release create v1.116.0 -n ''`.

assets/icon-archive.svg

@@ -1,60 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   width="60"
-   height="60"
-   viewBox="0 0 60 60"
-   fill="none"
-   stroke="currentColor"
-   stroke-width="2"
-   stroke-linecap="round"
-   stroke-linejoin="round"
-   class="feather feather-archive"
-   version="1.1"
-   id="svg8"
-   sodipodi:docname="icon-archive.svg"
-   inkscape:version="1.2.2 (b0a84865, 2022-12-01)"
-   inkscape:export-filename="icon-archive.png"
-   inkscape:export-xdpi="409.60001"
-   inkscape:export-ydpi="409.60001"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <defs
-     id="defs12" />
-  <sodipodi:namedview
-     id="namedview10"
-     pagecolor="#ffffff"
-     bordercolor="#000000"
-     borderopacity="0.25"
-     inkscape:showpageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     inkscape:deskcolor="#d1d1d1"
-     showgrid="false"
-     inkscape:zoom="6.4597151"
-     inkscape:cx="24.459283"
-     inkscape:cy="32.509174"
-     inkscape:window-width="1457"
-     inkscape:window-height="860"
-     inkscape:window-x="55"
-     inkscape:window-y="38"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="svg8" />
-  <g
-     id="g846"
-     transform="translate(0.558605,0.464417)">
-    <path
-       style="fill:none;fill-opacity:1;stroke:#808080;stroke-width:1.78186;stroke-dasharray:none;stroke-opacity:1"
-       d="M 38.749006,25.398867 V 38.843194 H 20.133784 V 25.398867"
-       id="path847" />
-    <path
-       style="fill:none;fill-opacity:1;stroke:#808080;stroke-width:1.78186;stroke-dasharray:none;stroke-opacity:1"
-       d="m 18.065427,20.227972 h 22.751936 v 5.170894 H 18.065427 Z"
-       id="path845" />
-    <path
-       style="fill:#ff0000;fill-opacity:1;stroke:#808080;stroke-width:1.78186;stroke-dasharray:none;stroke-opacity:1"
-       d="m 27.373036,29.535581 h 4.136718"
-       id="line6" />
-  </g>
-</svg>

benches/contacts.rs

@@ -14,7 +14,7 @@ async fn address_book_benchmark(n: u32, read_count: u32) {
         .unwrap();
 
     let book = (0..n)
-        .map(|i| format!("Name {i}\naddr{i}@example.org\n"))
+        .map(|i| format!("Name {}\naddr{}@example.org\n", i, i))
         .collect::<Vec<String>>()
         .join("");
 

benches/create_account.rs

@@ -1,15 +1,13 @@
-use std::path::PathBuf;
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::accounts::Accounts;
+use std::path::PathBuf;
 use tempfile::tempdir;
 
 async fn create_accounts(n: u32) {
     let dir = tempdir().unwrap();
     let p: PathBuf = dir.path().join("accounts");
 
-    let writable = true;
-    let mut accounts = Accounts::new(p.clone(), writable).await.unwrap();
+    let mut accounts = Accounts::new(p.clone()).await.unwrap();
 
     for expected_id in 2..n {
         let id = accounts.add_account().await.unwrap();

benches/get_chat_msgs.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
 use deltachat::chat::{self, ChatId};
 use deltachat::chatlist::Chatlist;
 use deltachat::context::Context;
@@ -14,7 +15,7 @@ async fn get_chat_msgs_benchmark(dbfile: &Path, chats: &[ChatId]) {
         .unwrap();
 
     for c in chats.iter().take(10) {
-        black_box(chat::get_chat_msgs(&context, *c).await.ok());
+        black_box(chat::get_chat_msgs(&context, *c, 0).await.ok());
     }
 }
 

benches/get_chatlist.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
 use deltachat::chatlist::Chatlist;
 use deltachat::context::Context;
 use deltachat::stock_str::StockStrings;

benches/search_msgs.rs

@@ -1,9 +1,8 @@
-use std::path::Path;
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::context::Context;
 use deltachat::stock_str::StockStrings;
 use deltachat::Events;
+use std::path::Path;
 
 async fn search_benchmark(dbfile: impl AsRef<Path>) {
     let id = 100;

benches/send_events.rs

@@ -1,47 +0,0 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-
-use deltachat::context::Context;
-use deltachat::stock_str::StockStrings;
-use deltachat::{info, Event, EventType, Events};
-use tempfile::tempdir;
-
-async fn send_events_benchmark(context: &Context) {
-    let emitter = context.get_event_emitter();
-    for _i in 0..1_000_000 {
-        info!(context, "interesting event...");
-    }
-    info!(context, "DONE");
-
-    loop {
-        match emitter.recv().await.unwrap() {
-            Event {
-                typ: EventType::Info(info),
-                ..
-            } if info.contains("DONE") => {
-                break;
-            }
-            _ => {}
-        }
-    }
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
-    let context = rt.block_on(async {
-        Context::new(&dbfile, 100, Events::new(), StockStrings::new())
-            .await
-            .expect("failed to create context")
-    });
-    let executor = tokio::runtime::Runtime::new().unwrap();
-
-    c.bench_function("Sending 1.000.000 events", |b| {
-        b.to_async(&executor)
-            .iter(|| send_events_benchmark(&context))
-    });
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

cliff.toml

@@ -1,79 +0,0 @@
-# configuration file for git-cliff
-# see https://git-cliff.org/docs/configuration/
-
-
-[git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = true
-# filter out the commits that are not conventional
-filter_unconventional = false
-# process each line of a commit as an individual commit
-split_commits = false
-# regex for preprocessing the commit messages
-commit_preprocessors = [
-    { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](https://github.com/deltachat/deltachat-core-rust/pull/${2}))"}, # replace pull request / issue numbers
-]
-# regex for parsing and grouping commits
-commit_parsers = [
-    { message = "^feat", group = "Features / Changes"},
-    { message = "^fix", group = "Fixes"},
-    { message = "^api", group = "API-Changes" },
-    { message = "^refactor", group = "Refactor"},
-    { message = "^perf", group = "Performance"},
-    { message = "^test", group = "Tests"},
-    { message = "^style", group = "Styling"},
-    { message = "^chore\\(release\\): prepare for", skip = true},
-    { message = "^chore", group = "Miscellaneous Tasks"},
-    { message = "^build", group = "Build system"},
-    { message = "^docs", group = "Documentation"},
-    { message = "^ci", group = "CI"},
-    { message = ".*", group = "Other"},
-#    { body = ".*security", group = "Security"},
-]
-# protect breaking changes from being skipped due to matching a skipping commit_parser
-protect_breaking_commits = true
-# filter out the commits that are not matched by commit parsers
-filter_commits = true
-# glob pattern for matching git tags
-tag_pattern = "v[0-9]*"
-# regex for skipping tags
-#skip_tags = "v0.1.0-beta.1"
-# regex for ignoring tags
-ignore_tags = ""
-# sort the tags topologically
-topo_order = false
-# sort the commits inside sections by oldest/newest order
-sort_commits = "oldest"
-# limit the number of commits included in the changelog.
-# limit_commits = 42
-
-
-[changelog]
-# changelog header
-header = """
-# Changelog\n
-"""
-# template for the changelog body
-# https://keats.github.io/tera/docs/#templates
-body = """
-{% if version %}\
-    ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
-{% else %}\
-    ## [unreleased]
-{% endif %}\
-{% for group, commits in commits | group_by(attribute="group") %}
-    ### {{ group | upper_first }}
-    {% for commit in commits %}
-        - {% if commit.breaking %}[**breaking**] {% endif %}\
-	{% if commit.scope %}{{ commit.scope }}: {% endif %}\
-	{{ commit.message | upper_first }}.\
-	{% if commit.footers is defined %}\
-	  {% for footer in commit.footers %}{% if 'BREAKING CHANGE' in footer.token %}
-	    {% raw %}  {% endraw %}- {{ footer.value }}\
-	  {% endif %}{% endfor %}\
-	{% endif%}\
-    {% endfor %}
-{% endfor %}\n
-"""
-# remove the leading and trailing whitespace from the template
-trim = true

deltachat-ffi/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "deltachat_ffi"
-version = "1.131.5"
+version = "1.103.0"
 description = "Deltachat FFI"
+authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 readme = "README.md"
 license = "MPL-2.0"
@@ -17,18 +18,18 @@ crate-type = ["cdylib", "staticlib"]
 deltachat = { path = "../", default-features = false }
 deltachat-jsonrpc = { path = "../deltachat-jsonrpc", optional = true }
 libc = "0.2"
-human-panic = { version = "1", default-features = false }
+human-panic = "1"
 num-traits = "0.2"
 serde_json = "1.0"
 tokio = { version = "1", features = ["rt-multi-thread"] }
 anyhow = "1"
 thiserror = "1"
-rand = "0.8"
-once_cell = "1.18.0"
-yerpc = { version = "0.5.1", features = ["anyhow_expose"] }
+rand = "0.7"
+once_cell = "1.16.0"
 
 [features]
 default = ["vendored"]
 vendored = ["deltachat/vendored"]
-jsonrpc = ["dep:deltachat-jsonrpc"]
+nightly = ["deltachat/nightly"]
+jsonrpc = ["deltachat-jsonrpc"]
 

deltachat-ffi/Doxyfile

@@ -846,7 +846,7 @@ EXCLUDE_PATTERNS       =
 # exclude all test directories use the pattern */test/*
 
 ######################################################
-EXCLUDE_SYMBOLS        = dc_aheader_t dc_apeerstate_t dc_e2ee_helper_t dc_imap_t dc_job*_t dc_key_t dc_loginparam_t dc_mime*_t
+EXCLUDE_SYMBOLS        = dc_aheader_t dc_apeerstate_t dc_e2ee_helper_t dc_imap_t dc_job*_t dc_key_t dc_keyring_t dc_loginparam_t dc_mime*_t
 EXCLUDE_SYMBOLS       += dc_saxparser_t dc_simplify_t dc_smtp_t dc_sqlite3_t dc_strbuilder_t dc_param_t dc_hash_t dc_hashelem_t
 EXCLUDE_SYMBOLS       += _dc_* jsmn*
 ######################################################

deltachat-ffi/Doxyfile.css

@@ -1,24 +1,14 @@
 
-:root {
-	--accent: hsl(0 0% 85%);
-}
-
-@media (prefers-color-scheme: dark) {
-	:root {
-		--accent: hsl(0 0% 25%);
-	}
-}
-
 /* the code snippet frame, defaults to white which tends to get badly readable in combination with explaining text around */
 div.fragment {
-	background-color: var(--accent);
+	background-color: #e0e0e0;
 	border: 0;
 	padding: 1em;
 	border-radius: 6px;
 }
 
 code {
-	background-color: var(--accent);
+	background-color: #e0e0e0;
 	padding-left: .5em;
 	padding-right: .5em;
 	border-radius: 6px;

deltachat-ffi/src/lot.rs

@@ -1,12 +1,10 @@
 //! # Legacy generic return values for C API.
 
-use std::borrow::Cow;
-
-use anyhow::Error;
-
 use crate::message::MessageState;
 use crate::qr::Qr;
 use crate::summary::{Summary, SummaryPrefix};
+use anyhow::Error;
+use std::borrow::Cow;
 
 /// An object containing a set of values.
 /// The meaning of the values is defined by the function returning the object.
@@ -14,8 +12,6 @@ use crate::summary::{Summary, SummaryPrefix};
 /// eg. by chatlist.get_summary() or dc_msg_get_summary().
 ///
 /// *Lot* is used in the meaning *heap* here.
-// The QR code grew too large.  So be it.
-#[allow(clippy::large_enum_variant)]
 #[derive(Debug)]
 pub enum Lot {
     Summary(Summary),
@@ -24,15 +20,20 @@ pub enum Lot {
 }
 
 #[repr(u8)]
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Meaning {
-    #[default]
     None = 0,
     Text1Draft = 1,
     Text1Username = 2,
     Text1Self = 3,
 }
 
+impl Default for Meaning {
+    fn default() -> Self {
+        Meaning::None
+    }
+}
+
 impl Lot {
     pub fn get_text1(&self) -> Option<&str> {
         match self {
@@ -49,7 +50,6 @@ impl Lot {
                 Qr::FprMismatch { .. } => None,
                 Qr::FprWithoutAddr { fingerprint, .. } => Some(fingerprint),
                 Qr::Account { domain } => Some(domain),
-                Qr::Backup { .. } => None,
                 Qr::WebrtcInstance { domain, .. } => Some(domain),
                 Qr::Addr { draft, .. } => draft.as_deref(),
                 Qr::Url { url } => Some(url),
@@ -101,7 +101,6 @@ impl Lot {
                 Qr::FprMismatch { .. } => LotState::QrFprMismatch,
                 Qr::FprWithoutAddr { .. } => LotState::QrFprWithoutAddr,
                 Qr::Account { .. } => LotState::QrAccount,
-                Qr::Backup { .. } => LotState::QrBackup,
                 Qr::WebrtcInstance { .. } => LotState::QrWebrtcInstance,
                 Qr::Addr { .. } => LotState::QrAddr,
                 Qr::Url { .. } => LotState::QrUrl,
@@ -126,7 +125,6 @@ impl Lot {
                 Qr::FprMismatch { contact_id } => contact_id.unwrap_or_default().to_u32(),
                 Qr::FprWithoutAddr { .. } => Default::default(),
                 Qr::Account { .. } => Default::default(),
-                Qr::Backup { .. } => Default::default(),
                 Qr::WebrtcInstance { .. } => Default::default(),
                 Qr::Addr { contact_id, .. } => contact_id.to_u32(),
                 Qr::Url { .. } => Default::default(),
@@ -151,9 +149,9 @@ impl Lot {
 }
 
 #[repr(u32)]
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum LotState {
-    #[default]
+    // Default
     Undefined = 0,
 
     // Qr States
@@ -175,8 +173,6 @@ pub enum LotState {
     /// text1=domain
     QrAccount = 250,
 
-    QrBackup = 251,
-
     /// text1=domain, text2=instance pattern
     QrWebrtcInstance = 260,
 
@@ -217,6 +213,12 @@ pub enum LotState {
     MsgOutMdnRcvd = 28,
 }
 
+impl Default for LotState {
+    fn default() -> Self {
+        LotState::Undefined
+    }
+}
+
 impl From<MessageState> for LotState {
     fn from(s: MessageState) -> Self {
         use MessageState::*;

deltachat-ffi/src/string.rs

@@ -287,9 +287,8 @@ fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
 
 #[cfg(test)]
 mod tests {
-    use libc::{free, strcmp};
-
     use super::*;
+    use libc::{free, strcmp};
 
     #[test]
     fn test_os_str_to_c_string_cwd() {

deltachat-jsonrpc/.gitignore

@@ -1,4 +1,3 @@
-openrpc/openrpc.json
 accounts/
 
 .cargo

deltachat-jsonrpc/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.131.5"
+version = "1.103.0"
 description = "DeltaChat JSON-RPC API"
+authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
 license = "MPL-2.0"
@@ -15,29 +16,26 @@ required-features = ["webserver"]
 anyhow = "1"
 deltachat = { path = ".." }
 num-traits = "0.2"
-schemars = "0.8.13"
 serde = { version = "1.0", features = ["derive"] }
-tempfile = "3.8.0"
+tempfile = "3.3.0"
 log = "0.4"
-async-channel = { version = "2.0.0" }
-futures = { version = "0.3.28" }
-serde_json = "1.0.105"
-yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }
-typescript-type-def = { version = "0.5.8", features = ["json_value"] }
-tokio = { version = "1.33.0" }
-sanitize-filename = "0.5"
-walkdir = "2.3.3"
-base64 = "0.21"
+async-channel = { version = "1.8.0" }
+futures = { version = "0.3.25" }
+serde_json = "1.0.89"
+yerpc = { version = "^0.3.1", features = ["anyhow_expose"] }
+typescript-type-def = { version = "0.5.5", features = ["json_value"] }
+tokio = { version = "1.22.0" }
+sanitize-filename = "0.4"
+walkdir = "2.3.2"
 
 # optional dependencies
-axum = { version = "0.6.20", optional = true, features = ["ws"] }
+axum = { version = "0.6.1", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.33.0", features = ["full", "rt-multi-thread"] }
+tokio = { version = "1.22.0", features = ["full", "rt-multi-thread"] }
 
 
 [features]
-default = ["vendored"]
-webserver = ["dep:env_logger", "dep:axum", "tokio/full", "yerpc/support-axum"]
-vendored = ["deltachat/vendored"]
+default = []
+webserver = ["env_logger", "axum", "tokio/full", "yerpc/support-axum"]

deltachat-jsonrpc/README.md

@@ -35,7 +35,7 @@ The server can be configured with environment variables:
 |`DC_PORT`|`20808`|port to listen on|
 |`DC_ACCOUNTS_PATH`|`./accounts`|path to storage directory|
 
-If you are targeting other architectures (like KaiOS or Android), the webserver binary can be cross-compiled easily with [rust-cross](https://github.com/cross-rs/cross):
+If you are targetting other architectures (like KaiOS or Android), the webserver binary can be cross-compiled easily with [rust-cross](https://github.com/cross-rs/cross):
 
 ```sh
 cross build --features=webserver --target armv7-linux-androideabi --release
@@ -108,10 +108,10 @@ This will build the `deltachat-jsonrpc-server` binary and then run a test suite
 
 The test suite includes some tests that need online connectivity and a way to create test email accounts. To run these tests, talk to DeltaChat developers to get a token for the `testrun.org` service, or use a local instance of [`mailadm`](https://github.com/deltachat/docker-mailadm).
 
-Then, set the `CHATMAIL_DOMAIN` environment variable to your testing email server domain.
+Then, set the `DCC_NEW_TMP_EMAIL` environment variable to your mailadm token before running the tests.
 
 ```
-CHATMAIL_DOMAIN=chat.example.org npm run test
+DCC_NEW_TMP_EMAIL=https://testrun.org/new_email?t=yourtoken npm run test
 ```
 
 #### Test Coverage

deltachat-jsonrpc/src/api/events.rs

@@ -1,29 +1,19 @@
-use deltachat::{Event as CoreEvent, EventType as CoreEventType};
+use deltachat::{Event, EventType};
 use serde::Serialize;
+use serde_json::{json, Value};
 use typescript_type_def::TypeDef;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct Event {
-    /// Event payload.
-    event: EventType,
-
-    /// Account ID.
-    context_id: u32,
+pub fn event_to_json_rpc_notification(event: Event) -> Value {
+    let id: JSONRPCEventType = event.typ.into();
+    json!({
+        "event": id,
+        "contextId": event.id,
+    })
 }
 
-impl From<CoreEvent> for Event {
-    fn from(event: CoreEvent) -> Self {
-        Event {
-            event: event.typ.into(),
-            context_id: event.id,
-        }
-    }
-}
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(tag = "kind")]
-pub enum EventType {
+#[derive(Serialize, TypeDef)]
+#[serde(tag = "type", rename = "Event")]
+pub enum JSONRPCEventType {
     /// The library-user may write an informational string to the log.
     ///
     /// This event should *not* be reported to the end-user using a popup or something like
@@ -57,9 +47,6 @@ pub enum EventType {
         msg: String,
     },
 
-    /// Emitted before going into IDLE on the Inbox folder.
-    ImapInboxIdle,
-
     /// Emitted when an new file in the $BLOBDIR was created
     NewBlobFile {
         file: String,
@@ -174,13 +161,6 @@ pub enum EventType {
         msg_id: u32,
     },
 
-    /// A single message is deleted.
-    #[serde(rename_all = "camelCase")]
-    MsgDeleted {
-        chat_id: u32,
-        msg_id: u32,
-    },
-
     /// Chat changed.  The name or the image of a chat group was changed or members were added or removed.
     /// Or the verify state of a chat has changed.
     /// See setChatName(), setChatProfileImage(), addContactToChat()
@@ -303,27 +283,26 @@ pub enum EventType {
     },
 }
 
-impl From<CoreEventType> for EventType {
-    fn from(event: CoreEventType) -> Self {
-        use EventType::*;
+impl From<EventType> for JSONRPCEventType {
+    fn from(event: EventType) -> Self {
+        use JSONRPCEventType::*;
         match event {
-            CoreEventType::Info(msg) => Info { msg },
-            CoreEventType::SmtpConnected(msg) => SmtpConnected { msg },
-            CoreEventType::ImapConnected(msg) => ImapConnected { msg },
-            CoreEventType::SmtpMessageSent(msg) => SmtpMessageSent { msg },
-            CoreEventType::ImapMessageDeleted(msg) => ImapMessageDeleted { msg },
-            CoreEventType::ImapMessageMoved(msg) => ImapMessageMoved { msg },
-            CoreEventType::ImapInboxIdle => ImapInboxIdle,
-            CoreEventType::NewBlobFile(file) => NewBlobFile { file },
-            CoreEventType::DeletedBlobFile(file) => DeletedBlobFile { file },
-            CoreEventType::Warning(msg) => Warning { msg },
-            CoreEventType::Error(msg) => Error { msg },
-            CoreEventType::ErrorSelfNotInGroup(msg) => ErrorSelfNotInGroup { msg },
-            CoreEventType::MsgsChanged { chat_id, msg_id } => MsgsChanged {
+            EventType::Info(msg) => Info { msg },
+            EventType::SmtpConnected(msg) => SmtpConnected { msg },
+            EventType::ImapConnected(msg) => ImapConnected { msg },
+            EventType::SmtpMessageSent(msg) => SmtpMessageSent { msg },
+            EventType::ImapMessageDeleted(msg) => ImapMessageDeleted { msg },
+            EventType::ImapMessageMoved(msg) => ImapMessageMoved { msg },
+            EventType::NewBlobFile(file) => NewBlobFile { file },
+            EventType::DeletedBlobFile(file) => DeletedBlobFile { file },
+            EventType::Warning(msg) => Warning { msg },
+            EventType::Error(msg) => Error { msg },
+            EventType::ErrorSelfNotInGroup(msg) => ErrorSelfNotInGroup { msg },
+            EventType::MsgsChanged { chat_id, msg_id } => MsgsChanged {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::ReactionsChanged {
+            EventType::ReactionsChanged {
                 chat_id,
                 msg_id,
                 contact_id,
@@ -332,80 +311,92 @@ impl From<CoreEventType> for EventType {
                 msg_id: msg_id.to_u32(),
                 contact_id: contact_id.to_u32(),
             },
-            CoreEventType::IncomingMsg { chat_id, msg_id } => IncomingMsg {
+            EventType::IncomingMsg { chat_id, msg_id } => IncomingMsg {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::IncomingMsgBunch { msg_ids } => IncomingMsgBunch {
+            EventType::IncomingMsgBunch { msg_ids } => IncomingMsgBunch {
                 msg_ids: msg_ids.into_iter().map(|id| id.to_u32()).collect(),
             },
-            CoreEventType::MsgsNoticed(chat_id) => MsgsNoticed {
+            EventType::MsgsNoticed(chat_id) => MsgsNoticed {
                 chat_id: chat_id.to_u32(),
             },
-            CoreEventType::MsgDelivered { chat_id, msg_id } => MsgDelivered {
+            EventType::MsgDelivered { chat_id, msg_id } => MsgDelivered {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::MsgFailed { chat_id, msg_id } => MsgFailed {
+            EventType::MsgFailed { chat_id, msg_id } => MsgFailed {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::MsgRead { chat_id, msg_id } => MsgRead {
+            EventType::MsgRead { chat_id, msg_id } => MsgRead {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::MsgDeleted { chat_id, msg_id } => MsgDeleted {
-                chat_id: chat_id.to_u32(),
-                msg_id: msg_id.to_u32(),
-            },
-            CoreEventType::ChatModified(chat_id) => ChatModified {
+            EventType::ChatModified(chat_id) => ChatModified {
                 chat_id: chat_id.to_u32(),
             },
-            CoreEventType::ChatEphemeralTimerModified { chat_id, timer } => {
+            EventType::ChatEphemeralTimerModified { chat_id, timer } => {
                 ChatEphemeralTimerModified {
                     chat_id: chat_id.to_u32(),
                     timer: timer.to_u32(),
                 }
             }
-            CoreEventType::ContactsChanged(contact) => ContactsChanged {
+            EventType::ContactsChanged(contact) => ContactsChanged {
                 contact_id: contact.map(|c| c.to_u32()),
             },
-            CoreEventType::LocationChanged(contact) => LocationChanged {
+            EventType::LocationChanged(contact) => LocationChanged {
                 contact_id: contact.map(|c| c.to_u32()),
             },
-            CoreEventType::ConfigureProgress { progress, comment } => {
+            EventType::ConfigureProgress { progress, comment } => {
                 ConfigureProgress { progress, comment }
             }
-            CoreEventType::ImexProgress(progress) => ImexProgress { progress },
-            CoreEventType::ImexFileWritten(path) => ImexFileWritten {
+            EventType::ImexProgress(progress) => ImexProgress { progress },
+            EventType::ImexFileWritten(path) => ImexFileWritten {
                 path: path.to_str().unwrap_or_default().to_owned(),
             },
-            CoreEventType::SecurejoinInviterProgress {
+            EventType::SecurejoinInviterProgress {
                 contact_id,
                 progress,
             } => SecurejoinInviterProgress {
                 contact_id: contact_id.to_u32(),
                 progress,
             },
-            CoreEventType::SecurejoinJoinerProgress {
+            EventType::SecurejoinJoinerProgress {
                 contact_id,
                 progress,
             } => SecurejoinJoinerProgress {
                 contact_id: contact_id.to_u32(),
                 progress,
             },
-            CoreEventType::ConnectivityChanged => ConnectivityChanged,
-            CoreEventType::SelfavatarChanged => SelfavatarChanged,
-            CoreEventType::WebxdcStatusUpdate {
+            EventType::ConnectivityChanged => ConnectivityChanged,
+            EventType::SelfavatarChanged => SelfavatarChanged,
+            EventType::WebxdcStatusUpdate {
                 msg_id,
                 status_update_serial,
             } => WebxdcStatusUpdate {
                 msg_id: msg_id.to_u32(),
                 status_update_serial: status_update_serial.to_u32(),
             },
-            CoreEventType::WebxdcInstanceDeleted { msg_id } => WebxdcInstanceDeleted {
+            EventType::WebxdcInstanceDeleted { msg_id } => WebxdcInstanceDeleted {
                 msg_id: msg_id.to_u32(),
             },
         }
     }
 }
+
+#[cfg(test)]
+#[test]
+fn generate_events_ts_types_definition() {
+    let events = {
+        let mut buf = Vec::new();
+        let options = typescript_type_def::DefinitionFileOptions {
+            root_namespace: None,
+            ..typescript_type_def::DefinitionFileOptions::default()
+        };
+        typescript_type_def::write_definition_file::<_, JSONRPCEventType>(&mut buf, options)
+            .unwrap();
+        String::from_utf8(buf).unwrap()
+    };
+    std::fs::write("typescript/generated/events.ts", events).unwrap();
+}

deltachat-jsonrpc/src/api/mod.rs

@@ -1,53 +1,51 @@
+use anyhow::{anyhow, bail, ensure, Context, Result};
+use deltachat::{
+    chat::{
+        self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, marknoticed_chat,
+        remove_contact_from_chat, Chat, ChatId, ChatItem, ProtectionStatus,
+    },
+    chatlist::Chatlist,
+    config::Config,
+    constants::DC_MSG_ID_DAYMARKER,
+    contact::{may_be_valid_addr, Contact, ContactId, Origin},
+    context::get_info,
+    ephemeral::Timer,
+    imex, location,
+    message::{
+        self, delete_msgs, get_msg_info, markseen_msgs, Message, MessageState, MsgId, Viewtype,
+    },
+    provider::get_provider_info,
+    qr,
+    qr_code_generator::get_securejoin_qr_svg,
+    reaction::send_reaction,
+    securejoin,
+    stock_str::StockMessage,
+    webxdc::StatusUpdateSerial,
+};
+use sanitize_filename::is_sanitized;
 use std::collections::BTreeMap;
 use std::sync::Arc;
 use std::{collections::HashMap, str::FromStr};
-
-use anyhow::{anyhow, bail, ensure, Context, Result};
-pub use deltachat::accounts::Accounts;
-use deltachat::chat::{
-    self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, get_chat_msgs_ex,
-    marknoticed_chat, remove_contact_from_chat, Chat, ChatId, ChatItem, MessageListOptions,
-    ProtectionStatus,
-};
-use deltachat::chatlist::Chatlist;
-use deltachat::config::Config;
-use deltachat::constants::DC_MSG_ID_DAYMARKER;
-use deltachat::contact::{may_be_valid_addr, Contact, ContactId, Origin};
-use deltachat::context::get_info;
-use deltachat::ephemeral::Timer;
-use deltachat::imex;
-use deltachat::location;
-use deltachat::message::get_msg_read_receipts;
-use deltachat::message::{
-    self, delete_msgs, markseen_msgs, Message, MessageState, MsgId, Viewtype,
-};
-use deltachat::provider::get_provider_info;
-use deltachat::qr::{self, Qr};
-use deltachat::qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg};
-use deltachat::reaction::{get_msg_reactions, send_reaction};
-use deltachat::securejoin;
-use deltachat::stock_str::StockMessage;
-use deltachat::webxdc::StatusUpdateSerial;
-use sanitize_filename::is_sanitized;
-use tokio::fs;
-use tokio::sync::{watch, Mutex, RwLock};
+use tokio::{fs, sync::RwLock};
 use walkdir::WalkDir;
 use yerpc::rpc;
 
+pub use deltachat::accounts::Accounts;
+
+pub mod events;
 pub mod types;
 
-use num_traits::FromPrimitive;
+use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
+use crate::api::types::qr::QrObject;
+
 use types::account::Account;
 use types::chat::FullChat;
+use types::chat_list::ChatListEntry;
 use types::contact::ContactObject;
-use types::events::Event;
-use types::http::HttpResponse;
-use types::message::{MessageData, MessageObject, MessageReadReceipt};
+use types::message::MessageObject;
 use types::provider_info::ProviderInfo;
-use types::reactions::JSONRPCReactions;
 use types::webxdc::WebxdcMessageInfo;
 
-use self::types::message::{MessageInfo, MessageLoadResult};
 use self::types::{
     chat::{BasicChat, JSONRPCChatVisibility, MuteDuration},
     location::JsonrpcLocation,
@@ -55,48 +53,24 @@ use self::types::{
         JSONRPCMessageListItem, MessageNotificationInfo, MessageSearchResult, MessageViewtype,
     },
 };
-use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
-use crate::api::types::qr::QrObject;
 
-#[derive(Debug)]
-struct AccountState {
-    /// The Qr code for current [`CommandApi::provide_backup`] call.
-    ///
-    /// If there currently is a call to [`CommandApi::provide_backup`] this will be
-    /// `Pending` or `Ready`, otherwise `NoProvider`.
-    backup_provider_qr: watch::Sender<ProviderQr>,
-}
-
-impl Default for AccountState {
-    fn default() -> Self {
-        let (tx, _rx) = watch::channel(ProviderQr::NoProvider);
-        Self {
-            backup_provider_qr: tx,
-        }
-    }
-}
+use num_traits::FromPrimitive;
 
 #[derive(Clone, Debug)]
 pub struct CommandApi {
     pub(crate) accounts: Arc<RwLock<Accounts>>,
-
-    states: Arc<Mutex<BTreeMap<u32, AccountState>>>,
 }
 
 impl CommandApi {
     pub fn new(accounts: Accounts) -> Self {
         CommandApi {
             accounts: Arc::new(RwLock::new(accounts)),
-            states: Arc::new(Mutex::new(BTreeMap::new())),
         }
     }
 
     #[allow(dead_code)]
     pub fn from_arc(accounts: Arc<RwLock<Accounts>>) -> Self {
-        CommandApi {
-            accounts,
-            states: Arc::new(Mutex::new(BTreeMap::new())),
-        }
+        CommandApi { accounts }
     }
 
     async fn get_context(&self, id: u32) -> Result<deltachat::context::Context> {
@@ -108,71 +82,24 @@ impl CommandApi {
             .ok_or_else(|| anyhow!("account with id {} not found", id))?;
         Ok(sc)
     }
-
-    async fn with_state<F, T>(&self, id: u32, with_state: F) -> T
-    where
-        F: FnOnce(&AccountState) -> T,
-    {
-        let mut states = self.states.lock().await;
-        let state = states.entry(id).or_insert_with(Default::default);
-        with_state(state)
-    }
-
-    async fn inner_get_backup_qr(&self, account_id: u32) -> Result<Qr> {
-        let mut receiver = self
-            .with_state(account_id, |state| state.backup_provider_qr.subscribe())
-            .await;
-
-        let val: ProviderQr = receiver.borrow_and_update().clone();
-        match val {
-            ProviderQr::NoProvider => bail!("No backup being provided"),
-            ProviderQr::Pending => loop {
-                if receiver.changed().await.is_err() {
-                    bail!("No backup being provided (account state dropped)");
-                }
-                let val: ProviderQr = receiver.borrow().clone();
-                match val {
-                    ProviderQr::NoProvider => bail!("No backup being provided"),
-                    ProviderQr::Pending => continue,
-                    ProviderQr::Ready(qr) => break Ok(qr),
-                };
-            },
-            ProviderQr::Ready(qr) => Ok(qr),
-        }
-    }
 }
 
 #[rpc(all_positional, ts_outdir = "typescript/generated")]
 impl CommandApi {
-    /// Test function.
-    async fn sleep(&self, delay: f64) {
-        tokio::time::sleep(std::time::Duration::from_secs_f64(delay)).await
-    }
-
     // ---------------------------------------------
     //  Misc top level functions
     // ---------------------------------------------
 
-    /// Checks if an email address is valid.
+    /// Check if an email address is valid.
     async fn check_email_validity(&self, email: String) -> bool {
         may_be_valid_addr(&email)
     }
 
-    /// Returns general system info.
+    /// Get general system info.
     async fn get_system_info(&self) -> BTreeMap<&'static str, String> {
         get_info()
     }
 
-    /// Get the next event.
-    async fn get_next_event(&self) -> Result<Event> {
-        let event_emitter = self.accounts.read().await.get_event_emitter();
-        event_emitter
-            .recv()
-            .await
-            .map(|event| event.into())
-            .context("event channel is closed")
-    }
-
     // ---------------------------------------------
     // Account Management
     // ---------------------------------------------
@@ -182,13 +109,7 @@ impl CommandApi {
     }
 
     async fn remove_account(&self, account_id: u32) -> Result<()> {
-        self.accounts
-            .write()
-            .await
-            .remove_account(account_id)
-            .await?;
-        self.states.lock().await.remove(&account_id);
-        Ok(())
+        self.accounts.write().await.remove_account(account_id).await
     }
 
     async fn get_all_account_ids(&self) -> Vec<u32> {
@@ -214,20 +135,20 @@ impl CommandApi {
             let context_option = self.accounts.read().await.get_account(id);
             if let Some(ctx) = context_option {
                 accounts.push(Account::from_context(&ctx, id).await?)
+            } else {
+                println!("account with id {} doesn't exist anymore", id);
             }
         }
         Ok(accounts)
     }
 
-    /// Starts background tasks for all accounts.
     async fn start_io_for_all_accounts(&self) -> Result<()> {
-        self.accounts.write().await.start_io().await;
+        self.accounts.read().await.start_io().await;
         Ok(())
     }
 
-    /// Stops background tasks for all accounts.
     async fn stop_io_for_all_accounts(&self) -> Result<()> {
-        self.accounts.write().await.stop_io().await;
+        self.accounts.read().await.stop_io().await;
         Ok(())
     }
 
@@ -235,16 +156,14 @@ impl CommandApi {
     // Methods that work on individual accounts
     // ---------------------------------------------
 
-    /// Starts background tasks for a single account.
-    async fn start_io(&self, account_id: u32) -> Result<()> {
-        let mut ctx = self.get_context(account_id).await?;
+    async fn start_io(&self, id: u32) -> Result<()> {
+        let ctx = self.get_context(id).await?;
         ctx.start_io().await;
         Ok(())
     }
 
-    /// Stops background tasks for a single account.
-    async fn stop_io(&self, account_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
+    async fn stop_io(&self, id: u32) -> Result<()> {
+        let ctx = self.get_context(id).await?;
         ctx.stop_io().await;
         Ok(())
     }
@@ -311,13 +230,11 @@ impl CommandApi {
         ctx.get_info().await
     }
 
-    /// Sets the given configuration key.
     async fn set_config(&self, account_id: u32, key: String, value: Option<String>) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
         set_config(&ctx, &key, value.as_deref()).await
     }
 
-    /// Updates a batch of configuration values.
     async fn batch_set_config(
         &self,
         account_id: u32,
@@ -327,7 +244,7 @@ impl CommandApi {
         for (key, value) in config.into_iter() {
             set_config(&ctx, &key, value.as_deref())
                 .await
-                .with_context(|| format!("Can't set {key} to {value:?}"))?;
+                .with_context(|| format!("Can't set {} to {:?}", key, value))?;
         }
         Ok(())
     }
@@ -349,7 +266,6 @@ impl CommandApi {
         Ok(qr_object)
     }
 
-    /// Returns configuration value for the given key.
     async fn get_config(&self, account_id: u32, key: String) -> Result<Option<String>> {
         let ctx = self.get_context(account_id).await?;
         get_config(&ctx, &key).await
@@ -383,7 +299,7 @@ impl CommandApi {
     /// Configures this account with the currently set parameters.
     /// Setup the credential config before calling this.
     async fn configure(&self, account_id: u32) -> Result<()> {
-        let mut ctx = self.get_context(account_id).await?;
+        let ctx = self.get_context(account_id).await?;
         ctx.stop_io().await;
         let result = ctx.configure().await;
         if result.is_err() {
@@ -467,49 +383,6 @@ impl CommandApi {
         ChatId::new(chat_id).get_fresh_msg_cnt(&ctx).await
     }
 
-    /// Gets messages to be processed by the bot and returns their IDs.
-    ///
-    /// Only messages with database ID higher than `last_msg_id` config value
-    /// are returned. After processing the messages, the bot should
-    /// update `last_msg_id` by calling [`markseen_msgs`]
-    /// or manually updating the value to avoid getting already
-    /// processed messages.
-    ///
-    /// [`markseen_msgs`]: Self::markseen_msgs
-    async fn get_next_msgs(&self, account_id: u32) -> Result<Vec<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let msg_ids = ctx
-            .get_next_msgs()
-            .await?
-            .iter()
-            .map(|msg_id| msg_id.to_u32())
-            .collect();
-        Ok(msg_ids)
-    }
-
-    /// Waits for messages to be processed by the bot and returns their IDs.
-    ///
-    /// This function is similar to [`get_next_msgs`],
-    /// but waits for internal new message notification before returning.
-    /// New message notification is sent when new message is added to the database,
-    /// on initialization, when I/O is started and when I/O is stopped.
-    /// This allows bots to use `wait_next_msgs` in a loop to process
-    /// old messages after initialization and during the bot runtime.
-    /// To shutdown the bot, stopping I/O can be used to interrupt
-    /// pending or next `wait_next_msgs` call.
-    ///
-    /// [`get_next_msgs`]: Self::get_next_msgs
-    async fn wait_next_msgs(&self, account_id: u32) -> Result<Vec<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let msg_ids = ctx
-            .wait_next_msgs()
-            .await?
-            .iter()
-            .map(|msg_id| msg_id.to_u32())
-            .collect();
-        Ok(msg_ids)
-    }
-
     /// Estimate the number of messages that will be deleted
     /// by the set_config()-options `delete_device_after` or `delete_server_after`.
     /// This is typically used to show the estimated impact to the user
@@ -553,7 +426,7 @@ impl CommandApi {
         list_flags: Option<u32>,
         query_string: Option<String>,
         query_contact_id: Option<u32>,
-    ) -> Result<Vec<u32>> {
+    ) -> Result<Vec<ChatListEntry>> {
         let ctx = self.get_context(account_id).await?;
         let list = Chatlist::try_load(
             &ctx,
@@ -562,44 +435,33 @@ impl CommandApi {
             query_contact_id.map(ContactId::new),
         )
         .await?;
-        let mut l: Vec<u32> = Vec::with_capacity(list.len());
+        let mut l: Vec<ChatListEntry> = Vec::with_capacity(list.len());
         for i in 0..list.len() {
-            l.push(list.get_chat_id(i)?.to_u32());
+            l.push(ChatListEntry(
+                list.get_chat_id(i)?.to_u32(),
+                list.get_msg_id(i)?.unwrap_or_default().to_u32(),
+            ));
         }
         Ok(l)
     }
 
-    /// Returns chats similar to the given one.
-    ///
-    /// Experimental API, subject to change without notice.
-    async fn get_similar_chat_ids(&self, account_id: u32, chat_id: u32) -> Result<Vec<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let chat_id = ChatId::new(chat_id);
-        let list = chat_id
-            .get_similar_chat_ids(&ctx)
-            .await?
-            .into_iter()
-            .map(|(chat_id, _metric)| chat_id.to_u32())
-            .collect();
-        Ok(list)
-    }
-
     async fn get_chatlist_items_by_entries(
         &self,
         account_id: u32,
-        entries: Vec<u32>,
+        entries: Vec<ChatListEntry>,
     ) -> Result<HashMap<u32, ChatListItemFetchResult>> {
+        // todo custom json deserializer for ChatListEntry?
         let ctx = self.get_context(account_id).await?;
         let mut result: HashMap<u32, ChatListItemFetchResult> =
             HashMap::with_capacity(entries.len());
-        for &entry in entries.iter() {
+        for entry in entries.iter() {
             result.insert(
-                entry,
+                entry.0,
                 match get_chat_list_item_by_id(&ctx, entry).await {
                     Ok(res) => res,
                     Err(err) => ChatListItemFetchResult::Error {
-                        id: entry,
-                        error: format!("{err:#}"),
+                        id: entry.0,
+                        error: format!("{:?}", err),
                     },
                 },
             );
@@ -678,7 +540,7 @@ impl CommandApi {
     ///     the Verified-Group-Invite protocol is offered in the QR code;
     ///     works for protected groups as well as for normal groups.
     ///     If not set, the Setup-Contact protocol is offered in the QR code.
-    ///     See https://securejoin.readthedocs.io/en/latest/new.html
+    ///     See https://countermitm.readthedocs.io/en/latest/new.html
     ///     for details about both protocols.
     ///
     /// return format: `[code, svg]`
@@ -707,7 +569,7 @@ impl CommandApi {
     ///
     /// Subsequent calls of `secure_join()` will abort previous, unfinished handshakes.
     ///
-    /// See https://securejoin.readthedocs.io/en/latest/new.html
+    /// See https://countermitm.readthedocs.io/en/latest/new.html
     /// for details about both protocols.
     ///
     /// **qr**: The text of the scanned QR code. Typically, the same string as given
@@ -815,12 +677,24 @@ impl CommandApi {
     /// Create a new broadcast list.
     ///
     /// Broadcast lists are similar to groups on the sending device,
-    /// however, recipients get the messages in a read-only chat
-    /// and will see who the other members are.
+    /// however, recipients get the messages in normal one-to-one chats
+    /// and will not be aware of other members.
     ///
-    /// For historical reasons, this function does not take a name directly,
-    /// instead you have to set the name using dc_set_chat_name()
-    /// after creating the broadcast list.
+    /// Replies to broadcasts go only to the sender
+    /// and not to all broadcast recipients.
+    /// Moreover, replies will not appear in the broadcast list
+    /// but in the one-to-one chat with the person answering.
+    ///
+    /// The name and the image of the broadcast list is set automatically
+    /// and is visible to the sender only.
+    /// Not asking for these data allows more focused creation
+    /// and we bypass the question who will get which data.
+    /// Also, many users will have at most one broadcast list
+    /// so, a generic name and image is sufficient at the first place.
+    ///
+    /// Later on, however, the name can be changed using dc_set_chat_name().
+    /// The image cannot be changed to have a unique, recognizable icon in the chat lists.
+    /// All in all, this is also what other messengers are doing here.
     async fn create_broadcast_list(&self, account_id: u32) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
         chat::create_broadcast_list(&ctx)
@@ -905,7 +779,7 @@ impl CommandApi {
     ) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
         let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(text);
+        msg.set_text(Some(text));
         let message_id =
             deltachat::chat::add_device_msg(&ctx, Some(&label), Some(&mut msg)).await?;
         Ok(message_id.to_u32())
@@ -931,7 +805,7 @@ impl CommandApi {
         let ctx = self.get_context(account_id).await?;
 
         // TODO: implement this in core with an SQL query, that will be way faster
-        let messages = get_chat_msgs(&ctx, ChatId::new(chat_id)).await?;
+        let messages = get_chat_msgs(&ctx, ChatId::new(chat_id), 0).await?;
         let mut first_unread_message_id = None;
         for item in messages.into_iter().rev() {
             if let ChatItem::Message { msg_id } = item {
@@ -1000,34 +874,15 @@ impl CommandApi {
     /// Moreover, timer is started for incoming ephemeral messages.
     /// This also happens for contact requests chats.
     ///
-    /// This function updates `last_msg_id` configuration value
-    /// to the maximum of the current value and IDs passed to this function.
-    /// Bots which mark messages as seen can rely on this side effect
-    /// to avoid updating `last_msg_id` value manually.
-    ///
     /// One #DC_EVENT_MSGS_NOTICED event is emitted per modified chat.
     async fn markseen_msgs(&self, account_id: u32, msg_ids: Vec<u32>) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
         markseen_msgs(&ctx, msg_ids.into_iter().map(MsgId::new).collect()).await
     }
 
-    async fn get_message_ids(
-        &self,
-        account_id: u32,
-        chat_id: u32,
-        info_only: bool,
-        add_daymarker: bool,
-    ) -> Result<Vec<u32>> {
+    async fn get_message_ids(&self, account_id: u32, chat_id: u32, flags: u32) -> Result<Vec<u32>> {
         let ctx = self.get_context(account_id).await?;
-        let msg = get_chat_msgs_ex(
-            &ctx,
-            ChatId::new(chat_id),
-            MessageListOptions {
-                info_only,
-                add_daymarker,
-            },
-        )
-        .await?;
+        let msg = get_chat_msgs(&ctx, ChatId::new(chat_id), flags).await?;
         Ok(msg
             .iter()
             .map(|chat_item| -> u32 {
@@ -1043,19 +898,10 @@ impl CommandApi {
         &self,
         account_id: u32,
         chat_id: u32,
-        info_only: bool,
-        add_daymarker: bool,
+        flags: u32,
     ) -> Result<Vec<JSONRPCMessageListItem>> {
         let ctx = self.get_context(account_id).await?;
-        let msg = get_chat_msgs_ex(
-            &ctx,
-            ChatId::new(chat_id),
-            MessageListOptions {
-                info_only,
-                add_daymarker,
-            },
-        )
-        .await?;
+        let msg = get_chat_msgs(&ctx, ChatId::new(chat_id), flags).await?;
         Ok(msg
             .iter()
             .map(|chat_item| (*chat_item).into())
@@ -1072,27 +918,17 @@ impl CommandApi {
         MsgId::new(message_id).get_html(&ctx).await
     }
 
-    /// get multiple messages in one call,
-    /// if loading one message fails the error is stored in the result object in it's place.
-    ///
-    /// this is the batch variant of [get_message]
     async fn get_messages(
         &self,
         account_id: u32,
         message_ids: Vec<u32>,
-    ) -> Result<HashMap<u32, MessageLoadResult>> {
+    ) -> Result<HashMap<u32, MessageObject>> {
         let ctx = self.get_context(account_id).await?;
-        let mut messages: HashMap<u32, MessageLoadResult> = HashMap::new();
+        let mut messages: HashMap<u32, MessageObject> = HashMap::new();
         for message_id in message_ids {
-            let message_result = MessageObject::from_message_id(&ctx, message_id).await;
             messages.insert(
                 message_id,
-                match message_result {
-                    Ok(message) => MessageLoadResult::Message(message),
-                    Err(error) => MessageLoadResult::LoadingError {
-                        error: format!("{error:#}"),
-                    },
-                },
+                MessageObject::from_message_id(&ctx, message_id).await?,
             );
         }
         Ok(messages)
@@ -1123,35 +959,7 @@ impl CommandApi {
     /// max. text returned by dc_msg_get_text() (about 30000 characters).
     async fn get_message_info(&self, account_id: u32, message_id: u32) -> Result<String> {
         let ctx = self.get_context(account_id).await?;
-        MsgId::new(message_id).get_info(&ctx).await
-    }
-
-    /// Returns additional information for single message.
-    async fn get_message_info_object(
-        &self,
-        account_id: u32,
-        message_id: u32,
-    ) -> Result<MessageInfo> {
-        let ctx = self.get_context(account_id).await?;
-        MessageInfo::from_msg_id(&ctx, MsgId::new(message_id)).await
-    }
-
-    /// Returns contacts that sent read receipts and the time of reading.
-    async fn get_message_read_receipts(
-        &self,
-        account_id: u32,
-        message_id: u32,
-    ) -> Result<Vec<MessageReadReceipt>> {
-        let ctx = self.get_context(account_id).await?;
-        let receipts = get_msg_read_receipts(&ctx, MsgId::new(message_id))
-            .await?
-            .iter()
-            .map(|(contact_id, ts)| MessageReadReceipt {
-                contact_id: contact_id.to_u32(),
-                timestamp: *ts,
-            })
-            .collect();
-        Ok(receipts)
+        get_msg_info(&ctx, MsgId::new(message_id)).await
     }
 
     /// Asks the core to start downloading a message fully.
@@ -1171,17 +979,17 @@ impl CommandApi {
     }
 
     /// Search messages containing the given query string.
-    /// Searching can be done globally (chat_id=None) or in a specified chat only (chat_id set).
+    /// Searching can be done globally (chat_id=0) or in a specified chat only (chat_id set).
     ///
-    /// Global search results are typically displayed using dc_msg_get_summary(), chat
-    /// search results may just highlight the corresponding messages and present a
+    /// Global chat results are typically displayed using dc_msg_get_summary(), chat
+    /// search results may just hilite the corresponding messages and present a
     /// prev/next button.
     ///
-    /// For the global search, the result is limited to 1000 messages,
-    /// this allows an incremental search done fast.
-    /// So, when getting exactly 1000 messages, the result actually may be truncated;
-    /// the UIs may display sth. like "1000+ messages found" in this case.
-    /// The chat search (if chat_id is set) is not limited.
+    /// For global search, result is limited to 1000 messages,
+    /// this allows incremental search done fast.
+    /// So, when getting exactly 1000 results, the result may be truncated;
+    /// the UIs may display sth. as "1000+ messages found" in this case.
+    /// Chat search (if a chat_id is set) is not limited.
     async fn search_messages(
         &self,
         account_id: u32,
@@ -1354,7 +1162,7 @@ impl CommandApi {
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
         let contact_id = ContactId::new(contact_id);
-        let contact = Contact::get_by_id(&ctx, contact_id).await?;
+        let contact = Contact::load_from_db(&ctx, contact_id).await?;
         let addr = contact.get_addr();
         Contact::create(&ctx, &name, addr).await?;
         Ok(())
@@ -1391,19 +1199,6 @@ impl CommandApi {
     //                   chat
     // ---------------------------------------------
 
-    /// Returns the [`ChatId`] for the 1:1 chat with `contact_id` if it exists.
-    ///
-    /// If it does not exist, `None` is returned.
-    async fn get_chat_id_by_contact_id(
-        &self,
-        account_id: u32,
-        contact_id: u32,
-    ) -> Result<Option<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let chat_id = ChatId::lookup_by_contact(&ctx, ContactId::new(contact_id)).await?;
-        Ok(chat_id.map(|id| id.to_u32()))
-    }
-
     /// Returns all message IDs of the given types in a chat.
     /// Typically used to show a gallery.
     ///
@@ -1441,10 +1236,6 @@ impl CommandApi {
     ///
     /// one combined call for getting chat::get_next_media for both directions
     /// the manual chat::get_next_media in only one direction is not exposed by the jsonrpc yet
-    ///
-    /// Deprecated 2023-10-03, use `get_chat_media` method
-    /// and navigate the returned array instead.
-    #[allow(deprecated)]
     async fn get_neighboring_chat_media(
         &self,
         account_id: u32,
@@ -1495,13 +1286,16 @@ impl CommandApi {
         passphrase: Option<String>,
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
-        imex::imex(
+        ctx.stop_io().await;
+        let result = imex::imex(
             &ctx,
             imex::ImexMode::ExportBackup,
             destination.as_ref(),
             passphrase,
         )
-        .await
+        .await;
+        ctx.start_io().await;
+        result
     }
 
     async fn import_backup(
@@ -1520,75 +1314,6 @@ impl CommandApi {
         .await
     }
 
-    /// Offers a backup for remote devices to retrieve.
-    ///
-    /// Can be cancelled by stopping the ongoing process.  Success or failure can be tracked
-    /// via the `ImexProgress` event which should either reach `1000` for success or `0` for
-    /// failure.
-    ///
-    /// This **stops IO** while it is running.
-    ///
-    /// Returns once a remote device has retrieved the backup, or is cancelled.
-    async fn provide_backup(&self, account_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        self.with_state(account_id, |state| {
-            state.backup_provider_qr.send_replace(ProviderQr::Pending);
-        })
-        .await;
-
-        let provider = imex::BackupProvider::prepare(&ctx).await?;
-        self.with_state(account_id, |state| {
-            state
-                .backup_provider_qr
-                .send_replace(ProviderQr::Ready(provider.qr()));
-        })
-        .await;
-
-        provider.await
-    }
-
-    /// Returns the text of the QR code for the running [`CommandApi::provide_backup`].
-    ///
-    /// This QR code text can be used in [`CommandApi::get_backup`] on a second device to
-    /// retrieve the backup and setup this second device.
-    ///
-    /// This call will fail if there is currently no concurrent call to
-    /// [`CommandApi::provide_backup`].  This call may block if the QR code is not yet
-    /// ready.
-    async fn get_backup_qr(&self, account_id: u32) -> Result<String> {
-        let qr = self.inner_get_backup_qr(account_id).await?;
-        qr::format_backup(&qr)
-    }
-
-    /// Returns the rendered QR code for the running [`CommandApi::provide_backup`].
-    ///
-    /// This QR code can be used in [`CommandApi::get_backup`] on a second device to
-    /// retrieve the backup and setup this second device.
-    ///
-    /// This call will fail if there is currently no concurrent call to
-    /// [`CommandApi::provide_backup`].  This call may block if the QR code is not yet
-    /// ready.
-    ///
-    /// Returns the QR code rendered as an SVG image.
-    async fn get_backup_qr_svg(&self, account_id: u32) -> Result<String> {
-        let ctx = self.get_context(account_id).await?;
-        let qr = self.inner_get_backup_qr(account_id).await?;
-        generate_backup_qr(&ctx, &qr).await
-    }
-
-    /// Gets a backup from a remote provider.
-    ///
-    /// This retrieves the backup from a remote device over the network and imports it into
-    /// the current device.
-    ///
-    /// Can be cancelled by stopping the ongoing process.
-    async fn get_backup(&self, account_id: u32, qr_text: String) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        let qr = qr::check_qr(&ctx, &qr_text).await?;
-        imex::get_backup(&ctx, qr).await?;
-        Ok(())
-    }
-
     // ---------------------------------------------
     //                connectivity
     // ---------------------------------------------
@@ -1699,32 +1424,6 @@ impl CommandApi {
         WebxdcMessageInfo::get_for_message(&ctx, MsgId::new(instance_msg_id)).await
     }
 
-    /// Get blob encoded as base64 from a webxdc message
-    ///
-    /// path is the path of the file within webxdc archive
-    async fn get_webxdc_blob(
-        &self,
-        account_id: u32,
-        instance_msg_id: u32,
-        path: String,
-    ) -> Result<String> {
-        let ctx = self.get_context(account_id).await?;
-        let message = Message::load_from_db(&ctx, MsgId::new(instance_msg_id)).await?;
-        let blob = message.get_webxdc_blob(&ctx, &path).await?;
-
-        use base64::{engine::general_purpose, Engine as _};
-        Ok(general_purpose::STANDARD_NO_PAD.encode(blob))
-    }
-
-    /// Makes an HTTP GET request and returns a response.
-    ///
-    /// `url` is the HTTP or HTTPS URL.
-    async fn get_http_response(&self, account_id: u32, url: String) -> Result<HttpResponse> {
-        let ctx = self.get_context(account_id).await?;
-        let response = deltachat::net::read_url_blob(&ctx, &url).await?.into();
-        Ok(response)
-    }
-
     /// Forward messages to another chat.
     ///
     /// All types of messages can be forwarded,
@@ -1742,20 +1441,6 @@ impl CommandApi {
         forward_msgs(&ctx, &message_ids, ChatId::new(chat_id)).await
     }
 
-    /// Resend messages and make information available for newly added chat members.
-    /// Resending sends out the original message, however, recipients and webxdc-status may differ.
-    /// Clients that already have the original message can still ignore the resent message as
-    /// they have tracked the state by dedicated updates.
-    ///
-    /// Some messages cannot be resent, eg. info-messages, drafts, already pending messages or messages that are not sent by SELF.
-    ///
-    /// message_ids all message IDs that should be resend. All messages must belong to the same chat.
-    async fn resend_messages(&self, account_id: u32, message_ids: Vec<u32>) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        let message_ids: Vec<MsgId> = message_ids.into_iter().map(MsgId::new).collect();
-        chat::resend_msgs(&ctx, &message_ids).await
-    }
-
     async fn send_sticker(
         &self,
         account_id: u32,
@@ -1767,9 +1452,6 @@ impl CommandApi {
         let mut msg = Message::new(Viewtype::Sticker);
         msg.set_file(&sticker_path, None);
 
-        // JSON-rpc does not need heuristics to turn [Viewtype::Sticker] into [Viewtype::Image]
-        msg.force_sticker();
-
         let message_id = deltachat::chat::send_msg(&ctx, ChatId::new(chat_id), &mut msg).await?;
         Ok(message_id.to_u32())
     }
@@ -1791,70 +1473,6 @@ impl CommandApi {
         Ok(message_id.to_u32())
     }
 
-    /// Returns reactions to the message.
-    async fn get_message_reactions(
-        &self,
-        account_id: u32,
-        message_id: u32,
-    ) -> Result<Option<JSONRPCReactions>> {
-        let ctx = self.get_context(account_id).await?;
-        let reactions = get_msg_reactions(&ctx, MsgId::new(message_id)).await?;
-        if reactions.is_empty() {
-            Ok(None)
-        } else {
-            Ok(Some(reactions.into()))
-        }
-    }
-
-    async fn send_msg(&self, account_id: u32, chat_id: u32, data: MessageData) -> Result<u32> {
-        let ctx = self.get_context(account_id).await?;
-        let mut message = Message::new(if let Some(viewtype) = data.viewtype {
-            viewtype.into()
-        } else if data.file.is_some() {
-            Viewtype::File
-        } else {
-            Viewtype::Text
-        });
-        message.set_text(data.text.unwrap_or_default());
-        if data.html.is_some() {
-            message.set_html(data.html);
-        }
-        if data.override_sender_name.is_some() {
-            message.set_override_sender_name(data.override_sender_name);
-        }
-        if let Some(file) = data.file {
-            message.set_file(file, None);
-        }
-        if let Some((latitude, longitude)) = data.location {
-            message.set_location(latitude, longitude);
-        }
-        if let Some(id) = data.quoted_message_id {
-            message
-                .set_quote(
-                    &ctx,
-                    Some(
-                        &Message::load_from_db(&ctx, MsgId::new(id))
-                            .await
-                            .context("message to quote could not be loaded")?,
-                    ),
-                )
-                .await?;
-        }
-        let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut message)
-            .await?
-            .to_u32();
-        Ok(msg_id)
-    }
-
-    /// Checks if messages can be sent to a given chat.
-    async fn can_send(&self, account_id: u32, chat_id: u32) -> Result<bool> {
-        let ctx = self.get_context(account_id).await?;
-        let chat_id = ChatId::new(chat_id);
-        let chat = Chat::load_from_db(&ctx, chat_id).await?;
-        let can_send = chat.can_send(&ctx).await?;
-        Ok(can_send)
-    }
-
     // ---------------------------------------------
     //           functions for the composer
     //    the composer is the message input field
@@ -1903,7 +1521,7 @@ impl CommandApi {
             .context("path conversion to string failed")
     }
 
-    /// Saves a sticker to a collection/folder in the account's sticker folder.
+    /// save a sticker to a collection/folder in the account's sticker folder
     async fn misc_save_sticker(
         &self,
         account_id: u32,
@@ -1996,7 +1614,7 @@ impl CommandApi {
         let ctx = self.get_context(account_id).await?;
 
         let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(text);
+        msg.set_text(Some(text));
 
         let message_id = deltachat::chat::send_msg(&ctx, ChatId::new(chat_id), &mut msg).await?;
         Ok(message_id.to_u32())
@@ -2019,7 +1637,9 @@ impl CommandApi {
         } else {
             Viewtype::Text
         });
-        message.set_text(text.unwrap_or_default());
+        if text.is_some() {
+            message.set_text(text);
+        }
         if let Some(file) = file {
             message.set_file(file, None);
         }
@@ -2056,20 +1676,16 @@ impl CommandApi {
         text: Option<String>,
         file: Option<String>,
         quoted_message_id: Option<u32>,
-        view_type: Option<MessageViewtype>,
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
-        let mut draft = Message::new(view_type.map_or_else(
-            || {
-                if file.is_some() {
-                    Viewtype::File
-                } else {
-                    Viewtype::Text
-                }
-            },
-            |v| v.into(),
-        ));
-        draft.set_text(text.unwrap_or_default());
+        let mut draft = Message::new(if file.is_some() {
+            Viewtype::File
+        } else {
+            Viewtype::Text
+        });
+        if text.is_some() {
+            draft.set_text(text);
+        }
         if let Some(file) = file {
             draft.set_file(file, None);
         }
@@ -2088,23 +1704,6 @@ impl CommandApi {
 
         ChatId::new(chat_id).set_draft(&ctx, Some(&mut draft)).await
     }
-
-    // send the chat's current set draft
-    async fn misc_send_draft(&self, account_id: u32, chat_id: u32) -> Result<u32> {
-        let ctx = self.get_context(account_id).await?;
-        if let Some(draft) = ChatId::new(chat_id).get_draft(&ctx).await? {
-            let mut draft = draft;
-            let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut draft)
-                .await?
-                .to_u32();
-            Ok(msg_id)
-        } else {
-            Err(anyhow!(
-                "chat with id {} doesn't have draft message",
-                chat_id
-            ))
-        }
-    }
 }
 
 // Helper functions (to prevent code duplication)
@@ -2117,7 +1716,7 @@ async fn set_config(
         ctx.set_ui_config(key, value).await?;
     } else {
         ctx.set_config(
-            Config::from_str(key).with_context(|| format!("unknown key {key:?}"))?,
+            Config::from_str(key).with_context(|| format!("unknown key {:?}", key))?,
             value,
         )
         .await?;
@@ -2139,19 +1738,7 @@ async fn get_config(
     if key.starts_with("ui.") {
         ctx.get_ui_config(key).await
     } else {
-        ctx.get_config(Config::from_str(key).with_context(|| format!("unknown key {key:?}"))?)
+        ctx.get_config(Config::from_str(key).with_context(|| format!("unknown key {:?}", key))?)
             .await
     }
 }
-
-/// Whether a QR code for a BackupProvider is currently available.
-#[allow(clippy::large_enum_variant)]
-#[derive(Clone, Debug)]
-enum ProviderQr {
-    /// There is no provider, asking for a QR is an error.
-    NoProvider,
-    /// There is a provider, the QR code is pending.
-    Pending,
-    /// There is a provider and QR code.
-    Ready(Qr),
-}

deltachat-jsonrpc/src/api/types/account.rs

@@ -6,8 +6,8 @@ use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(tag = "kind")]
+#[derive(Serialize, TypeDef)]
+#[serde(tag = "type")]
 pub enum Account {
     #[serde(rename_all = "camelCase")]
     Configured {

deltachat-jsonrpc/src/api/types/chat.rs

@@ -1,6 +1,6 @@
 use std::time::{Duration, SystemTime};
 
-use anyhow::{bail, Context as _, Result};
+use anyhow::{anyhow, bail, Result};
 use deltachat::chat::{self, get_chat_contacts, ChatVisibility};
 use deltachat::chat::{Chat, ChatId};
 use deltachat::constants::Chattype;
@@ -13,22 +13,11 @@ use typescript_type_def::TypeDef;
 use super::color_int_to_hex_string;
 use super::contact::ContactObject;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename_all = "camelCase")]
 pub struct FullChat {
     id: u32,
     name: String,
-
-    /// True if the chat is protected.
-    ///
-    /// UI should display a green checkmark
-    /// in the chat title,
-    /// in the chat profile title and
-    /// in the chatlist item
-    /// if chat protection is enabled.
-    /// UI should also display a green checkmark
-    /// in the contact profile
-    /// if 1:1 chat with this contact exists and is protected.
     is_protected: bool,
     profile_image: Option<String>, //BLOBS ?
     archived: bool,
@@ -42,7 +31,6 @@ pub struct FullChat {
     fresh_message_counter: usize,
     // is_group - please check over chat.type in frontend instead
     is_contact_request: bool,
-    is_protection_broken: bool,
     is_device_chat: bool,
     self_in_group: bool,
     is_muted: bool,
@@ -65,9 +53,7 @@ impl FullChat {
             contacts.push(
                 ContactObject::try_from_dc_contact(
                     context,
-                    Contact::get_by_id(context, *contact_id)
-                        .await
-                        .context("failed to load contact")?,
+                    Contact::load_from_db(context, *contact_id).await?,
                 )
                 .await?,
             )
@@ -86,9 +72,8 @@ impl FullChat {
 
         let was_seen_recently = if chat.get_type() == Chattype::Single {
             match contact_ids.get(0) {
-                Some(contact) => Contact::get_by_id(context, *contact)
-                    .await
-                    .context("failed to load contact for was_seen_recently")?
+                Some(contact) => Contact::load_from_db(context, *contact)
+                    .await?
                     .was_seen_recently(),
                 None => false,
             }
@@ -104,7 +89,10 @@ impl FullChat {
             is_protected: chat.is_protected(),
             profile_image, //BLOBS ?
             archived: chat.get_visibility() == chat::ChatVisibility::Archived,
-            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
+            chat_type: chat
+                .get_type()
+                .to_u32()
+                .ok_or_else(|| anyhow!("unknown chat type id"))?, // TODO get rid of this unwrap?
             is_unpromoted: chat.is_unpromoted(),
             is_self_talk: chat.is_self_talk(),
             contacts,
@@ -112,7 +100,6 @@ impl FullChat {
             color,
             fresh_message_counter,
             is_contact_request: chat.is_contact_request(),
-            is_protection_broken: chat.is_protection_broken(),
             is_device_chat: chat.is_device_talk(),
             self_in_group: contact_ids.contains(&ContactId::SELF),
             is_muted: chat.is_muted(),
@@ -134,22 +121,11 @@ impl FullChat {
 /// - can_send
 ///
 /// used when you only need the basic metadata of a chat like type, name, profile picture
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename_all = "camelCase")]
 pub struct BasicChat {
     id: u32,
     name: String,
-
-    /// True if the chat is protected.
-    ///
-    /// UI should display a green checkmark
-    /// in the chat title,
-    /// in the chat profile title and
-    /// in the chatlist item
-    /// if chat protection is enabled.
-    /// UI should also display a green checkmark
-    /// in the contact profile
-    /// if 1:1 chat with this contact exists and is protected.
     is_protected: bool,
     profile_image: Option<String>, //BLOBS ?
     archived: bool,
@@ -158,7 +134,6 @@ pub struct BasicChat {
     is_self_talk: bool,
     color: String,
     is_contact_request: bool,
-    is_protection_broken: bool,
     is_device_chat: bool,
     is_muted: bool,
 }
@@ -180,24 +155,25 @@ impl BasicChat {
             is_protected: chat.is_protected(),
             profile_image, //BLOBS ?
             archived: chat.get_visibility() == chat::ChatVisibility::Archived,
-            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
+            chat_type: chat
+                .get_type()
+                .to_u32()
+                .ok_or_else(|| anyhow!("unknown chat type id"))?, // TODO get rid of this unwrap?
             is_unpromoted: chat.is_unpromoted(),
             is_self_talk: chat.is_self_talk(),
             color,
             is_contact_request: chat.is_contact_request(),
-            is_protection_broken: chat.is_protection_broken(),
             is_device_chat: chat.is_device_talk(),
             is_muted: chat.is_muted(),
         })
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(tag = "kind")]
+#[derive(Clone, Serialize, Deserialize, TypeDef)]
 pub enum MuteDuration {
     NotMuted,
     Forever,
-    Until { duration: i64 },
+    Until(i64),
 }
 
 impl MuteDuration {
@@ -205,20 +181,20 @@ impl MuteDuration {
         match self {
             MuteDuration::NotMuted => Ok(chat::MuteDuration::NotMuted),
             MuteDuration::Forever => Ok(chat::MuteDuration::Forever),
-            MuteDuration::Until { duration } => {
-                if duration <= 0 {
+            MuteDuration::Until(n) => {
+                if n <= 0 {
                     bail!("failed to read mute duration")
                 }
 
                 Ok(SystemTime::now()
-                    .checked_add(Duration::from_secs(duration as u64))
+                    .checked_add(Duration::from_secs(n as u64))
                     .map_or(chat::MuteDuration::Forever, chat::MuteDuration::Until))
             }
         }
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
+#[derive(Clone, Serialize, Deserialize, TypeDef)]
 #[serde(rename = "ChatVisibility")]
 pub enum JSONRPCChatVisibility {
     Normal,

deltachat-jsonrpc/src/api/types/chat_list.rs

@@ -1,21 +1,25 @@
-use anyhow::{Context, Result};
-use deltachat::chat::{Chat, ChatId};
-use deltachat::chatlist::get_last_message_for_chat;
+use anyhow::Result;
 use deltachat::constants::*;
 use deltachat::contact::{Contact, ContactId};
 use deltachat::{
     chat::{get_chat_contacts, ChatVisibility},
     chatlist::Chatlist,
 };
+use deltachat::{
+    chat::{Chat, ChatId},
+    message::MsgId,
+};
 use num_traits::cast::ToPrimitive;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
-use super::message::MessageViewtype;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(tag = "kind")]
+#[derive(Deserialize, Serialize, TypeDef)]
+pub struct ChatListEntry(pub u32, pub u32);
+
+#[derive(Serialize, TypeDef)]
+#[serde(tag = "type")]
 pub enum ChatListItemFetchResult {
     #[serde(rename_all = "camelCase")]
     ChatListItem {
@@ -27,8 +31,6 @@ pub enum ChatListItemFetchResult {
         summary_text1: String,
         summary_text2: String,
         summary_status: u32,
-        /// showing preview if last chat message is image
-        summary_preview_image: Option<String>,
         is_protected: bool,
         is_group: bool,
         fresh_message_counter: usize,
@@ -45,40 +47,35 @@ pub enum ChatListItemFetchResult {
         /// contact id if this is a dm chat (for view profile entry in context menu)
         dm_chat_contact: Option<u32>,
         was_seen_recently: bool,
-        last_message_type: Option<MessageViewtype>,
-        last_message_id: Option<u32>,
     },
+    ArchiveLink,
     #[serde(rename_all = "camelCase")]
-    ArchiveLink { fresh_message_counter: usize },
-    #[serde(rename_all = "camelCase")]
-    Error { id: u32, error: String },
+    Error {
+        id: u32,
+        error: String,
+    },
 }
 
 pub(crate) async fn get_chat_list_item_by_id(
     ctx: &deltachat::context::Context,
-    entry: u32,
+    entry: &ChatListEntry,
 ) -> Result<ChatListItemFetchResult> {
-    let chat_id = ChatId::new(entry);
-    let fresh_message_counter = chat_id.get_fresh_msg_cnt(ctx).await?;
+    let chat_id = ChatId::new(entry.0);
+    let last_msgid = match entry.1 {
+        0 => None,
+        _ => Some(MsgId::new(entry.1)),
+    };
 
     if chat_id.is_archived_link() {
-        return Ok(ChatListItemFetchResult::ArchiveLink {
-            fresh_message_counter,
-        });
+        return Ok(ChatListItemFetchResult::ArchiveLink);
     }
 
-    let last_msgid = get_last_message_for_chat(ctx, chat_id).await?;
-
-    let chat = Chat::load_from_db(ctx, chat_id).await.context("chat")?;
-    let summary = Chatlist::get_summary2(ctx, chat_id, last_msgid, Some(&chat))
-        .await
-        .context("summary")?;
+    let chat = Chat::load_from_db(ctx, chat_id).await?;
+    let summary = Chatlist::get_summary2(ctx, chat_id, last_msgid, Some(&chat)).await?;
 
     let summary_text1 = summary.prefix.map_or_else(String::new, |s| s.to_string());
     let summary_text2 = summary.text.to_owned();
 
-    let summary_preview_image = summary.thumbnail_path;
-
     let visibility = chat.get_visibility();
 
     let avatar_path = chat
@@ -86,15 +83,12 @@ pub(crate) async fn get_chat_list_item_by_id(
         .await?
         .map(|path| path.to_str().unwrap_or("invalid/path").to_owned());
 
-    let (last_updated, message_type) = match last_msgid {
+    let last_updated = match last_msgid {
         Some(id) => {
             let last_message = deltachat::message::Message::load_from_db(ctx, id).await?;
-            (
-                Some(last_message.get_timestamp() * 1000),
-                Some(last_message.get_viewtype().into()),
-            )
+            Some(last_message.get_timestamp() * 1000)
         }
-        None => (None, None),
+        None => None,
     };
 
     let chat_contacts = get_chat_contacts(ctx, chat_id).await?;
@@ -104,9 +98,8 @@ pub(crate) async fn get_chat_list_item_by_id(
     let (dm_chat_contact, was_seen_recently) = if chat.get_type() == Chattype::Single {
         let contact = chat_contacts.get(0);
         let was_seen_recently = match contact {
-            Some(contact) => Contact::get_by_id(ctx, *contact)
-                .await
-                .context("contact")?
+            Some(contact) => Contact::load_from_db(ctx, *contact)
+                .await?
                 .was_seen_recently(),
             None => false,
         };
@@ -118,6 +111,7 @@ pub(crate) async fn get_chat_list_item_by_id(
         (None, false)
     };
 
+    let fresh_message_counter = chat_id.get_fresh_msg_cnt(ctx).await?;
     let color = color_int_to_hex_string(chat.get_color(ctx).await?);
 
     Ok(ChatListItemFetchResult::ChatListItem {
@@ -129,7 +123,6 @@ pub(crate) async fn get_chat_list_item_by_id(
         summary_text1,
         summary_text2,
         summary_status: summary.state.to_u32().expect("impossible"), // idea and a function to transform the constant to strings? or return string enum
-        summary_preview_image,
         is_protected: chat.is_protected(),
         is_group: chat.get_type() == Chattype::Group,
         fresh_message_counter,
@@ -144,7 +137,5 @@ pub(crate) async fn get_chat_list_item_by_id(
         is_broadcast: chat.get_type() == Chattype::Broadcast,
         dm_chat_contact,
         was_seen_recently,
-        last_message_type: message_type,
-        last_message_id: last_msgid.map(|id| id.to_u32()),
     })
 }

deltachat-jsonrpc/src/api/types/contact.rs

@@ -6,7 +6,7 @@ use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename = "Contact", rename_all = "camelCase")]
 pub struct ContactObject {
     address: String,
@@ -19,30 +19,7 @@ pub struct ContactObject {
     profile_image: Option<String>, // BLOBS
     name_and_addr: String,
     is_blocked: bool,
-
-    /// True if the contact can be added to verified groups.
-    ///
-    /// If this is true
-    /// UI should display green checkmark after the contact name
-    /// in contact list items,
-    /// in chat member list items
-    /// and in profiles if no chat with the contact exist.
     is_verified: bool,
-
-    /// True if the contact profile title should have a green checkmark.
-    ///
-    /// This indicates whether 1:1 chat has a green checkmark
-    /// or will have a green checkmark if created.
-    is_profile_verified: bool,
-
-    /// The ID of the contact that verified this contact.
-    ///
-    /// If this is present,
-    /// display a green checkmark and "Introduced by ..."
-    /// string followed by the verifier contact name and address
-    /// in the contact profile.
-    verifier_id: Option<u32>,
-
     /// the contact's last seen timestamp
     last_seen: i64,
     was_seen_recently: bool,
@@ -58,12 +35,6 @@ impl ContactObject {
             None => None,
         };
         let is_verified = contact.is_verified(context).await? == VerifiedStatus::BidirectVerified;
-        let is_profile_verified = contact.is_profile_verified(context).await?;
-
-        let verifier_id = contact
-            .get_verifier_id(context)
-            .await?
-            .map(|contact_id| contact_id.to_u32());
 
         Ok(ContactObject {
             address: contact.get_addr().to_owned(),
@@ -77,8 +48,6 @@ impl ContactObject {
             name_and_addr: contact.get_name_n_addr(),
             is_blocked: contact.is_blocked(),
             is_verified,
-            is_profile_verified,
-            verifier_id,
             last_seen: contact.last_seen(),
             was_seen_recently: contact.was_seen_recently(),
         })

deltachat-jsonrpc/src/api/types/http.rs

@@ -1,29 +0,0 @@
-use deltachat::net::HttpResponse as CoreHttpResponse;
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-pub struct HttpResponse {
-    /// base64-encoded response body.
-    blob: String,
-
-    /// MIME type, e.g. "text/plain" or "text/html".
-    mimetype: Option<String>,
-
-    /// Encoding, e.g. "utf-8".
-    encoding: Option<String>,
-}
-
-impl From<CoreHttpResponse> for HttpResponse {
-    fn from(response: CoreHttpResponse) -> Self {
-        use base64::{engine::general_purpose, Engine as _};
-        let blob = general_purpose::STANDARD_NO_PAD.encode(response.blob);
-        let mimetype = response.mimetype;
-        let encoding = response.encoding;
-        HttpResponse {
-            blob,
-            mimetype,
-            encoding,
-        }
-    }
-}

deltachat-jsonrpc/src/api/types/location.rs

@@ -2,7 +2,7 @@ use deltachat::location::Location;
 use serde::Serialize;
 use typescript_type_def::TypeDef;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename = "Location", rename_all = "camelCase")]
 pub struct JsonrpcLocation {
     pub location_id: u32,

deltachat-jsonrpc/src/api/types/message.rs

@@ -1,7 +1,7 @@
-use anyhow::{Context as _, Result};
+use anyhow::{anyhow, Result};
 use deltachat::chat::Chat;
 use deltachat::chat::ChatItem;
-use deltachat::chat::ChatVisibility;
+use deltachat::constants::Chattype;
 use deltachat::contact::Contact;
 use deltachat::context::Context;
 use deltachat::download;
@@ -10,7 +10,8 @@ use deltachat::message::MsgId;
 use deltachat::message::Viewtype;
 use deltachat::reaction::get_msg_reactions;
 use num_traits::cast::ToPrimitive;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+use serde::Serialize;
 use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
@@ -18,14 +19,7 @@ use super::contact::ContactObject;
 use super::reactions::JSONRPCReactions;
 use super::webxdc::WebxdcMessageInfo;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase", tag = "kind")]
-pub enum MessageLoadResult {
-    Message(MessageObject),
-    LoadingError { error: String },
-}
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename = "Message", rename_all = "camelCase")]
 pub struct MessageObject {
     id: u32,
@@ -34,7 +28,7 @@ pub struct MessageObject {
     quote: Option<MessageQuote>,
     parent_id: Option<u32>,
 
-    text: String,
+    text: Option<String>,
     has_location: bool,
     has_html: bool,
     view_type: MessageViewtype,
@@ -54,10 +48,6 @@ pub struct MessageObject {
     is_setupmessage: bool,
     is_info: bool,
     is_forwarded: bool,
-
-    /// True if the message was sent by a bot.
-    is_bot: bool,
-
     /// when is_info is true this describes what type of system message it is
     system_message_type: SystemMessageType,
 
@@ -85,7 +75,7 @@ pub struct MessageObject {
     reactions: Option<JSONRPCReactions>,
 }
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(tag = "kind")]
 enum MessageQuote {
     JustText {
@@ -113,13 +103,9 @@ impl MessageObject {
     pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<Self> {
         let message = Message::load_from_db(context, msg_id).await?;
 
-        let sender_contact = Contact::get_by_id(context, message.get_from_id())
-            .await
-            .context("failed to load sender contact")?;
-        let sender = ContactObject::try_from_dc_contact(context, sender_contact)
-            .await
-            .context("failed to load sender contact object")?;
-        let file_bytes = message.get_filebytes(context).await?.unwrap_or_default();
+        let sender_contact = Contact::load_from_db(context, message.get_from_id()).await?;
+        let sender = ContactObject::try_from_dc_contact(context, sender_contact).await?;
+        let file_bytes = message.get_filebytes(context).await;
         let override_sender_name = message.get_override_sender_name();
 
         let webxdc_info = if message.get_viewtype() == Viewtype::Webxdc {
@@ -135,9 +121,7 @@ impl MessageObject {
         let quote = if let Some(quoted_text) = message.quoted_text() {
             match message.quoted_message(context).await? {
                 Some(quote) => {
-                    let quote_author = Contact::get_by_id(context, quote.get_from_id())
-                        .await
-                        .context("failed to load quote author contact")?;
+                    let quote_author = Contact::load_from_db(context, quote.get_from_id()).await?;
                     Some(MessageQuote::WithMessage {
                         text: quoted_text,
                         message_id: quote.get_id().to_u32(),
@@ -165,9 +149,7 @@ impl MessageObject {
             None
         };
 
-        let reactions = get_msg_reactions(context, msg_id)
-            .await
-            .context("failed to load message reactions")?;
+        let reactions = get_msg_reactions(context, msg_id).await?;
         let reactions = if reactions.is_empty() {
             None
         } else {
@@ -187,7 +169,7 @@ impl MessageObject {
             state: message
                 .get_state()
                 .to_u32()
-                .context("state conversion to number failed")?,
+                .ok_or_else(|| anyhow!("state conversion to number failed"))?,
             error: message.error(),
 
             timestamp: message.get_timestamp(),
@@ -200,7 +182,6 @@ impl MessageObject {
             is_setupmessage: message.is_setupmessage(),
             is_info: message.is_info(),
             is_forwarded: message.is_forwarded(),
-            is_bot: message.is_bot(),
             system_message_type: message.get_info_type().into(),
 
             duration: message.get_duration(),
@@ -210,7 +191,7 @@ impl MessageObject {
             videochat_type: match message.get_videochat_type() {
                 Some(vct) => Some(
                     vct.to_u32()
-                        .context("videochat type conversion to number failed")?,
+                        .ok_or_else(|| anyhow!("state conversion to number failed"))?,
                 ),
                 None => None,
             },
@@ -237,7 +218,7 @@ impl MessageObject {
     }
 }
 
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, Deserialize, TypeDef)]
 #[serde(rename = "Viewtype")]
 pub enum MessageViewtype {
     Unknown,
@@ -313,12 +294,11 @@ impl From<MessageViewtype> for Viewtype {
     }
 }
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 pub enum DownloadState {
     Done,
     Available,
     Failure,
-    Undecipherable,
     InProgress,
 }
 
@@ -328,13 +308,12 @@ impl From<download::DownloadState> for DownloadState {
             download::DownloadState::Done => DownloadState::Done,
             download::DownloadState::Available => DownloadState::Available,
             download::DownloadState::Failure => DownloadState::Failure,
-            download::DownloadState::Undecipherable => DownloadState::Undecipherable,
             download::DownloadState::InProgress => DownloadState::InProgress,
         }
     }
 }
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 pub enum SystemMessageType {
     Unknown,
     GroupNameChanged,
@@ -389,7 +368,7 @@ impl From<deltachat::mimeparser::SystemMessage> for SystemMessageType {
     }
 }
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename_all = "camelCase")]
 pub struct MessageNotificationInfo {
     id: u32,
@@ -447,22 +426,14 @@ impl MessageNotificationInfo {
     }
 }
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename_all = "camelCase")]
 pub struct MessageSearchResult {
     id: u32,
     author_profile_image: Option<String>,
-    /// if sender name if overridden it will show it as ~alias
     author_name: String,
     author_color: String,
-    author_id: u32,
-    chat_profile_image: Option<String>,
-    chat_color: String,
-    chat_name: String,
-    chat_type: u32,
-    is_chat_protected: bool,
-    is_chat_contact_request: bool,
-    is_chat_archived: bool,
+    chat_name: Option<String>,
     message: String,
     timestamp: i64,
 }
@@ -471,44 +442,30 @@ impl MessageSearchResult {
     pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<Self> {
         let message = Message::load_from_db(context, msg_id).await?;
         let chat = Chat::load_from_db(context, message.get_chat_id()).await?;
-        let sender = Contact::get_by_id(context, message.get_from_id()).await?;
+        let sender = Contact::load_from_db(context, message.get_from_id()).await?;
 
         let profile_image = match sender.get_profile_image(context).await? {
             Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
             None => None,
         };
-        let chat_profile_image = match chat.get_profile_image(context).await? {
-            Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
-            None => None,
-        };
-
-        let author_name = if let Some(name) = message.get_override_sender_name() {
-            format!("~{name}")
-        } else {
-            sender.get_display_name().to_owned()
-        };
-        let chat_color = color_int_to_hex_string(chat.get_color(context).await?);
 
         Ok(Self {
             id: msg_id.to_u32(),
             author_profile_image: profile_image,
-            author_name,
+            author_name: sender.get_display_name().to_owned(),
             author_color: color_int_to_hex_string(sender.get_color()),
-            author_id: sender.id.to_u32(),
-            chat_name: chat.get_name().to_owned(),
-            chat_color,
-            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
-            chat_profile_image,
-            is_chat_protected: chat.is_protected(),
-            is_chat_contact_request: chat.is_contact_request(),
-            is_chat_archived: chat.get_visibility() == ChatVisibility::Archived,
-            message: message.get_text(),
+            chat_name: if chat.get_type() == Chattype::Single {
+                Some(chat.get_name().to_owned())
+            } else {
+                None
+            },
+            message: message.get_text().unwrap_or_default(),
             timestamp: message.get_timestamp(),
         })
     }
 }
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename_all = "camelCase", rename = "MessageListItem", tag = "kind")]
 pub enum JSONRPCMessageListItem {
     Message {
@@ -533,90 +490,3 @@ impl From<ChatItem> for JSONRPCMessageListItem {
         }
     }
 }
-
-#[derive(Deserialize, Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct MessageData {
-    pub text: Option<String>,
-    pub html: Option<String>,
-    pub viewtype: Option<MessageViewtype>,
-    pub file: Option<String>,
-    pub location: Option<(f64, f64)>,
-    pub override_sender_name: Option<String>,
-    pub quoted_message_id: Option<u32>,
-}
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct MessageReadReceipt {
-    pub contact_id: u32,
-    pub timestamp: i64,
-}
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct MessageInfo {
-    rawtext: String,
-    ephemeral_timer: EphemeralTimer,
-    /// When message is ephemeral this contains the timestamp of the message expiry
-    ephemeral_timestamp: Option<i64>,
-    error: Option<String>,
-    rfc724_mid: String,
-    server_urls: Vec<String>,
-    hop_info: Option<String>,
-}
-
-impl MessageInfo {
-    pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<Self> {
-        let message = Message::load_from_db(context, msg_id).await?;
-        let rawtext = msg_id.rawtext(context).await?;
-        let ephemeral_timer = message.get_ephemeral_timer().into();
-        let ephemeral_timestamp = match message.get_ephemeral_timer() {
-            deltachat::ephemeral::Timer::Disabled => None,
-            deltachat::ephemeral::Timer::Enabled { .. } => Some(message.get_ephemeral_timestamp()),
-        };
-
-        let server_urls =
-            MsgId::get_info_server_urls(context, message.rfc724_mid().to_owned()).await?;
-
-        let hop_info = msg_id.hop_info(context).await?;
-
-        Ok(Self {
-            rawtext,
-            ephemeral_timer,
-            ephemeral_timestamp,
-            error: message.error(),
-            rfc724_mid: message.rfc724_mid().to_owned(),
-            server_urls,
-            hop_info,
-        })
-    }
-}
-
-#[derive(
-    Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema,
-)]
-#[serde(rename_all = "camelCase", tag = "variant")]
-pub enum EphemeralTimer {
-    /// Timer is disabled.
-    Disabled,
-
-    /// Timer is enabled.
-    Enabled {
-        /// Timer duration in seconds.
-        ///
-        /// The value cannot be 0.
-        duration: u32,
-    },
-}
-
-impl From<deltachat::ephemeral::Timer> for EphemeralTimer {
-    fn from(value: deltachat::ephemeral::Timer) -> Self {
-        match value {
-            deltachat::ephemeral::Timer::Disabled => EphemeralTimer::Disabled,
-            deltachat::ephemeral::Timer::Enabled { duration } => {
-                EphemeralTimer::Enabled { duration }
-            }
-        }
-    }
-}

deltachat-jsonrpc/src/api/types/mod.rs

@@ -2,8 +2,6 @@ pub mod account;
 pub mod chat;
 pub mod chat_list;
 pub mod contact;
-pub mod events;
-pub mod http;
 pub mod location;
 pub mod message;
 pub mod provider_info;
@@ -12,7 +10,7 @@ pub mod reactions;
 pub mod webxdc;
 
 pub fn color_int_to_hex_string(color: u32) -> String {
-    format!("{color:#08x}").replace("0x", "#")
+    format!("{:#08x}", color).replace("0x", "#")
 }
 
 fn maybe_empty_string_to_option(string: String) -> Option<String> {

deltachat-jsonrpc/src/api/types/provider_info.rs

@@ -3,20 +3,17 @@ use num_traits::cast::ToPrimitive;
 use serde::Serialize;
 use typescript_type_def::TypeDef;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename_all = "camelCase")]
 pub struct ProviderInfo {
-    /// Unique ID, corresponding to provider database filename.
-    pub id: String,
     pub before_login_hint: String,
     pub overview_page: String,
-    pub status: u32, // in reality this is an enum, but for simplicity and because it gets converted into a number anyway, we use an u32 here.
+    pub status: u32, // in reality this is an enum, but for simlicity and because it gets converted into a number anyway, we use an u32 here.
 }
 
 impl ProviderInfo {
     pub fn from_dc_type(provider: Option<&Provider>) -> Option<Self> {
         provider.map(|p| ProviderInfo {
-            id: p.id.to_owned(),
             before_login_hint: p.before_login_hint.to_owned(),
             overview_page: p.overview_page.to_owned(),
             status: p.status.to_u32().unwrap(),

deltachat-jsonrpc/src/api/types/qr.rs

@@ -2,9 +2,9 @@ use deltachat::qr::Qr;
 use serde::Serialize;
 use typescript_type_def::TypeDef;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename = "Qr", rename_all = "camelCase")]
-#[serde(tag = "kind")]
+#[serde(tag = "type")]
 pub enum QrObject {
     AskVerifyContact {
         contact_id: u32,
@@ -32,9 +32,6 @@ pub enum QrObject {
     Account {
         domain: String,
     },
-    Backup {
-        ticket: String,
-    },
     WebrtcInstance {
         domain: String,
         instance_pattern: String,
@@ -129,9 +126,6 @@ impl From<Qr> for QrObject {
             }
             Qr::FprWithoutAddr { fingerprint } => QrObject::FprWithoutAddr { fingerprint },
             Qr::Account { domain } => QrObject::Account { domain },
-            Qr::Backup { ticket } => QrObject::Backup {
-                ticket: ticket.to_string(),
-            },
             Qr::WebrtcInstance {
                 domain,
                 instance_pattern,

deltachat-jsonrpc/src/api/types/reactions.rs

@@ -1,37 +1,23 @@
 use std::collections::BTreeMap;
 
-use deltachat::contact::ContactId;
 use deltachat::reaction::Reactions;
 use serde::Serialize;
 use typescript_type_def::TypeDef;
 
-/// A single reaction emoji.
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename = "Reaction", rename_all = "camelCase")]
-pub struct JSONRPCReaction {
-    /// Emoji.
-    emoji: String,
-
-    /// Emoji frequency.
-    count: usize,
-
-    /// True if we reacted with this emoji.
-    is_from_self: bool,
-}
-
 /// Structure representing all reactions to a particular message.
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename = "Reactions", rename_all = "camelCase")]
 pub struct JSONRPCReactions {
     /// Map from a contact to it's reaction to message.
     reactions_by_contact: BTreeMap<u32, Vec<String>>,
-    /// Unique reactions and their count, sorted in descending order.
-    reactions: Vec<JSONRPCReaction>,
+    /// Unique reactions and their count
+    reactions: BTreeMap<String, u32>,
 }
 
 impl From<Reactions> for JSONRPCReactions {
     fn from(reactions: Reactions) -> Self {
         let mut reactions_by_contact: BTreeMap<u32, Vec<String>> = BTreeMap::new();
+        let mut unique_reactions: BTreeMap<String, u32> = BTreeMap::new();
 
         for contact_id in reactions.contacts() {
             let reaction = reactions.get(contact_id);
@@ -44,29 +30,18 @@ impl From<Reactions> for JSONRPCReactions {
                 .map(|emoji| emoji.to_owned())
                 .collect();
             reactions_by_contact.insert(contact_id.to_u32(), emojis.clone());
-        }
-
-        let self_reactions = reactions_by_contact.get(&ContactId::SELF.to_u32());
-
-        let mut reactions_v = Vec::new();
-        for (emoji, count) in reactions.emoji_sorted_by_frequency() {
-            let is_from_self = if let Some(self_reactions) = self_reactions {
-                self_reactions.contains(&emoji)
-            } else {
-                false
-            };
-
-            let reaction = JSONRPCReaction {
-                emoji,
-                count,
-                is_from_self,
-            };
-            reactions_v.push(reaction)
+            for emoji in emojis {
+                if let Some(x) = unique_reactions.get_mut(&emoji) {
+                    *x += 1;
+                } else {
+                    unique_reactions.insert(emoji, 1);
+                }
+            }
         }
 
         JSONRPCReactions {
             reactions_by_contact,
-            reactions: reactions_v,
+            reactions: unique_reactions,
         }
     }
 }

deltachat-jsonrpc/src/api/types/webxdc.rs

@@ -8,7 +8,7 @@ use typescript_type_def::TypeDef;
 
 use super::maybe_empty_string_to_option;
 
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[derive(Serialize, TypeDef)]
 #[serde(rename = "WebxdcMessageInfo", rename_all = "camelCase")]
 pub struct WebxdcMessageInfo {
     /// The name of the app.

deltachat-jsonrpc/src/lib.rs

@@ -1,23 +1,22 @@
 pub mod api;
+pub use api::events;
 pub use yerpc;
 
 #[cfg(test)]
 mod tests {
+    use super::api::{Accounts, CommandApi};
     use async_channel::unbounded;
     use futures::StreamExt;
     use tempfile::TempDir;
     use yerpc::{RpcClient, RpcSession};
 
-    use super::api::{Accounts, CommandApi};
-
     #[tokio::test(flavor = "multi_thread")]
     async fn basic_json_rpc_functionality() -> anyhow::Result<()> {
         let tmp_dir = TempDir::new().unwrap().path().into();
-        let writable = true;
-        let accounts = Accounts::new(tmp_dir, writable).await?;
+        let accounts = Accounts::new(tmp_dir).await?;
         let api = CommandApi::new(accounts);
 
-        let (sender, receiver) = unbounded::<String>();
+        let (sender, mut receiver) = unbounded::<String>();
 
         let (client, mut rx) = RpcClient::new();
         let session = RpcSession::new(client, api);
@@ -36,17 +35,17 @@ mod tests {
             let request = r#"{"jsonrpc":"2.0","method":"add_account","params":[],"id":1}"#;
             let response = r#"{"jsonrpc":"2.0","id":1,"result":1}"#;
             session.handle_incoming(request).await;
-            let result = receiver.recv().await?;
-            println!("{result:?}");
-            assert_eq!(result, response.to_owned());
+            let result = receiver.next().await;
+            println!("{:?}", result);
+            assert_eq!(result, Some(response.to_owned()));
         }
         {
             let request = r#"{"jsonrpc":"2.0","method":"get_all_account_ids","params":[],"id":2}"#;
             let response = r#"{"jsonrpc":"2.0","id":2,"result":[1]}"#;
             session.handle_incoming(request).await;
-            let result = receiver.recv().await?;
-            println!("{result:?}");
-            assert_eq!(result, response.to_owned());
+            let result = receiver.next().await;
+            println!("{:?}", result);
+            assert_eq!(result, Some(response.to_owned()));
         }
 
         Ok(())
@@ -55,11 +54,10 @@ mod tests {
     #[tokio::test(flavor = "multi_thread")]
     async fn test_batch_set_config() -> anyhow::Result<()> {
         let tmp_dir = TempDir::new().unwrap().path().into();
-        let writable = true;
-        let accounts = Accounts::new(tmp_dir, writable).await?;
+        let accounts = Accounts::new(tmp_dir).await?;
         let api = CommandApi::new(accounts);
 
-        let (sender, receiver) = unbounded::<String>();
+        let (sender, mut receiver) = unbounded::<String>();
 
         let (client, mut rx) = RpcClient::new();
         let session = RpcSession::new(client, api);
@@ -78,15 +76,15 @@ mod tests {
             let request = r#"{"jsonrpc":"2.0","method":"add_account","params":[],"id":1}"#;
             let response = r#"{"jsonrpc":"2.0","id":1,"result":1}"#;
             session.handle_incoming(request).await;
-            let result = receiver.recv().await?;
-            assert_eq!(result, response.to_owned());
+            let result = receiver.next().await;
+            assert_eq!(result, Some(response.to_owned()));
         }
         {
             let request = r#"{"jsonrpc":"2.0","method":"batch_set_config","id":2,"params":[1,{"addr":"","mail_user":"","mail_pw":"","mail_server":"","mail_port":"","mail_security":"","imap_certificate_checks":"","send_user":"","send_pw":"","send_server":"","send_port":"","send_security":"","smtp_certificate_checks":"","socks5_enabled":"0","socks5_host":"","socks5_port":"","socks5_user":"","socks5_password":""}]}"#;
             let response = r#"{"jsonrpc":"2.0","id":2,"result":null}"#;
             session.handle_incoming(request).await;
-            let result = receiver.recv().await?;
-            assert_eq!(result, response.to_owned());
+            let result = receiver.next().await;
+            assert_eq!(result, Some(response.to_owned()));
         }
 
         Ok(())

deltachat-jsonrpc/src/webserver.rs

@@ -1,11 +1,11 @@
+use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use std::net::SocketAddr;
 use std::path::PathBuf;
-
-use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use yerpc::axum::handle_ws_rpc;
 use yerpc::{RpcClient, RpcSession};
 
 mod api;
+use api::events::event_to_json_rpc_notification;
 use api::{Accounts, CommandApi};
 
 const DEFAULT_PORT: u16 = 20808;
@@ -19,8 +19,7 @@ async fn main() -> Result<(), std::io::Error> {
         .map(|port| port.parse::<u16>().expect("DC_PORT must be a number"))
         .unwrap_or(DEFAULT_PORT);
     log::info!("Starting with accounts directory `{path}`.");
-    let writable = true;
-    let accounts = Accounts::new(PathBuf::from(&path), writable).await.unwrap();
+    let accounts = Accounts::new(PathBuf::from(&path)).await.unwrap();
     let state = CommandApi::new(accounts);
 
     let app = Router::new()
@@ -28,7 +27,7 @@ async fn main() -> Result<(), std::io::Error> {
         .layer(Extension(state.clone()));
 
     tokio::spawn(async move {
-        state.accounts.write().await.start_io().await;
+        state.accounts.read().await.start_io().await;
     });
 
     let addr = SocketAddr::from(([127, 0, 0, 1], port));
@@ -44,5 +43,12 @@ async fn main() -> Result<(), std::io::Error> {
 async fn handler(ws: WebSocketUpgrade, Extension(api): Extension<CommandApi>) -> Response {
     let (client, out_receiver) = RpcClient::new();
     let session = RpcSession::new(client.clone(), api.clone());
+    tokio::spawn(async move {
+        let events = api.accounts.read().await.get_event_emitter();
+        while let Some(event) = events.recv().await {
+            let event = event_to_json_rpc_notification(event);
+            client.send_notification("event", Some(event)).await.ok();
+        }
+    });
     handle_ws_rpc(ws, out_receiver, session).await
 }

deltachat-jsonrpc/typescript/.npmignore

@@ -4,9 +4,3 @@ docs
 coverage
 yarn*
 package-lock.json
-.prettierignore
-example.html
-report_api_coverage.mjs
-scripts
-dist/example
-dist/test

deltachat-jsonrpc/typescript/example/example.ts

@@ -35,7 +35,7 @@ async function run() {
     const accounts = await client.rpc.getAllAccounts();
     console.log("accounts loaded", accounts);
     for (const account of accounts) {
-      if (account.kind === "Configured") {
+      if (account.type === "Configured") {
         write(
           $head,
           `<a href="#" onclick="selectDeltaAccount(${account.id})">
@@ -57,7 +57,7 @@ async function run() {
     clear($main);
     const selectedAccount = SELECTED_ACCOUNT;
     const info = await client.rpc.getAccountInfo(selectedAccount);
-    if (info.kind !== "Configured") {
+    if (info.type !== "Configured") {
       return write($main, "Account is not configured");
     }
     write($main, `<h2>${info.addr!}</h2>`);
@@ -67,22 +67,23 @@ async function run() {
       null,
       null
     );
-    for (const chatId of chats) {
-      const chat = await client.rpc.getFullChatById(selectedAccount, chatId);
+    for (const [chatId, _messageId] of chats) {
+      const chat = await client.rpc.getFullChatById(
+        selectedAccount,
+        chatId
+      );
       write($main, `<h3>${chat.name}</h3>`);
       const messageIds = await client.rpc.getMessageIds(
         selectedAccount,
         chatId,
-        false,
-        false
+        0
       );
       const messages = await client.rpc.getMessages(
         selectedAccount,
         messageIds
       );
       for (const [_messageId, message] of Object.entries(messages)) {
-        if (message.kind === "message") write($main, `<p>${message.text}</p>`);
-        else write($main, `<p>loading error: ${message.error}</p>`);
+        write($main, `<p>${message.text}</p>`);
       }
     }
   }
@@ -92,9 +93,9 @@ async function run() {
       $side,
       `
         <p class="message">
-          [<strong>${event.kind}</strong> on account ${accountId}]<br>
+          [<strong>${event.type}</strong> on account ${accountId}]<br>
           <em>f1:</em> ${JSON.stringify(
-            Object.assign({}, event, { kind: undefined })
+            Object.assign({}, event, { type: undefined })
           )}
         </p>`
     );

deltachat-jsonrpc/typescript/example/node-add-account.js

@@ -3,27 +3,24 @@ import { DeltaChat } from "../dist/deltachat.js";
 run().catch(console.error);
 
 async function run() {
-  const delta = new DeltaChat("ws://localhost:20808/ws");
+  const delta = new DeltaChat('ws://localhost:20808/ws');
   delta.on("event", (event) => {
     console.log("event", event.data);
   });
 
-  const email = process.argv[2];
-  const password = process.argv[3];
-  if (!email || !password)
-    throw new Error(
-      "USAGE: node node-add-account.js <EMAILADDRESS> <PASSWORD>"
-    );
-  console.log(`creating account for ${email}`);
-  const id = await delta.rpc.addAccount();
-  console.log(`created account id ${id}`);
+  const email = process.argv[2]
+  const password = process.argv[3]
+  if (!email || !password) throw new Error('USAGE: node node-add-account.js <EMAILADDRESS> <PASSWORD>')
+  console.log(`creating acccount for ${email}`)
+  const id = await delta.rpc.addAccount()
+  console.log(`created account id ${id}`)
   await delta.rpc.setConfig(id, "addr", email);
   await delta.rpc.setConfig(id, "mail_pw", password);
-  console.log("configuration updated");
-  await delta.rpc.configure(id);
-  console.log("account configured!");
+  console.log('configuration updated')
+  await delta.rpc.configure(id)
+  console.log('account configured!')
 
   const accounts = await delta.rpc.getAllAccounts();
   console.log("accounts", accounts);
-  console.log("waiting for events...");
+  console.log("waiting for events...")
 }

deltachat-jsonrpc/typescript/example/node-demo.js

@@ -10,5 +10,5 @@ async function run() {
 
   const accounts = await delta.rpc.getAllAccounts();
   console.log("accounts", accounts);
-  console.log("waiting for events...");
+  console.log("waiting for events...")
 }

deltachat-jsonrpc/typescript/package.json

@@ -3,38 +3,33 @@
   "dependencies": {
     "@deltachat/tiny-emitter": "3.0.0",
     "isomorphic-ws": "^4.0.1",
-    "yerpc": "^0.4.3"
+    "yerpc": "^0.3.3"
   },
   "devDependencies": {
     "@types/chai": "^4.2.21",
     "@types/chai-as-promised": "^7.1.5",
     "@types/mocha": "^9.0.0",
+    "@types/node-fetch": "^2.5.7",
     "@types/ws": "^7.2.4",
     "c8": "^7.10.0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
-    "esbuild": "^0.17.9",
+    "esbuild": "^0.14.11",
     "http-server": "^14.1.1",
     "mocha": "^9.1.1",
+    "node-fetch": "^2.6.1",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.6.2",
     "typedoc": "^0.23.2",
     "typescript": "^4.5.5",
     "ws": "^8.5.0"
   },
-  "exports": {
-    ".": {
-      "import": "./dist/deltachat.js",
-      "require": "./dist/deltachat.cjs"
-    }
-  },
   "license": "MPL-2.0",
   "main": "dist/deltachat.js",
   "name": "@deltachat/jsonrpc-client",
   "scripts": {
-    "build": "run-s generate-bindings extract-constants build:tsc build:bundle build:cjs",
+    "build": "run-s generate-bindings extract-constants build:tsc build:bundle",
     "build:bundle": "esbuild --format=esm --bundle dist/deltachat.js --outfile=dist/deltachat.bundle.js",
-    "build:cjs": "esbuild --format=cjs --bundle --packages=external dist/deltachat.js --outfile=dist/deltachat.cjs",
     "build:tsc": "tsc",
     "docs": "typedoc --out docs deltachat.ts",
     "example": "run-s build example:build example:start",
@@ -43,8 +38,8 @@
     "example:start": "http-server .",
     "extract-constants": "node ./scripts/generate-constants.js",
     "generate-bindings": "cargo test",
-    "prettier:check": "prettier --check .",
-    "prettier:fix": "prettier --write .",
+    "prettier:check": "prettier --check **.ts",
+    "prettier:fix": "prettier --write **.ts",
     "test": "run-s test:prepare test:run-coverage test:report-coverage",
     "test:prepare": "cargo build --package deltachat-rpc-server --bin deltachat-rpc-server",
     "test:report-coverage": "node report_api_coverage.mjs",
@@ -53,5 +48,5 @@
   },
   "type": "module",
   "types": "dist/deltachat.d.ts",
-  "version": "1.131.5"
-}
+  "version": "1.103.0"
+}

deltachat-jsonrpc/typescript/report_api_coverage.mjs

@@ -1,5 +1,5 @@
 import { readFileSync } from "fs";
-// only checks for the coverage of the api functions in bindings.ts for now
+// only checks for the coverge of the api functions in bindings.ts for now
 const generatedFile = "typescript/generated/client.ts";
 const json = JSON.parse(readFileSync("./coverage/coverage-final.json"));
 const jsonCoverage =

deltachat-jsonrpc/typescript/src/client.ts

@@ -1,28 +1,34 @@
 import * as T from "../generated/types.js";
-import { EventType } from "../generated/types.js";
 import * as RPC from "../generated/jsonrpc.js";
 import { RawClient } from "../generated/client.js";
+import { Event } from "../generated/events.js";
 import { WebsocketTransport, BaseTransport, Request } from "yerpc";
 import { TinyEmitter } from "@deltachat/tiny-emitter";
 
-type Events = { ALL: (accountId: number, event: EventType) => void } & {
-  [Property in EventType["kind"]]: (
+type DCWireEvent<T extends Event> = {
+  event: T;
+  contextId: number;
+};
+// export type Events = Record<
+//   Event["type"] | "ALL",
+//   (event: DeltaChatEvent<Event>) => void
+// >;
+
+type Events = { ALL: (accountId: number, event: Event) => void } & {
+  [Property in Event["type"]]: (
     accountId: number,
-    event: Extract<EventType, { kind: Property }>
+    event: Extract<Event, { type: Property }>
   ) => void;
 };
 
-type ContextEvents = { ALL: (event: EventType) => void } & {
-  [Property in EventType["kind"]]: (
-    event: Extract<EventType, { kind: Property }>
+type ContextEvents = { ALL: (event: Event) => void } & {
+  [Property in Event["type"]]: (
+    event: Extract<Event, { type: Property }>
   ) => void;
 };
 
-export type DcEvent = EventType;
-export type DcEventType<T extends EventType["kind"]> = Extract<
-  EventType,
-  { kind: T }
->;
+export type DcEvent = Event;
+export type DcEventType<T extends Event["type"]> = Extract<Event, { type: T }>;
 
 export class BaseDeltaChat<
   Transport extends BaseTransport<any>
@@ -30,34 +36,27 @@ export class BaseDeltaChat<
   rpc: RawClient;
   account?: T.Account;
   private contextEmitters: { [key: number]: TinyEmitter<ContextEvents> } = {};
-
-  //@ts-ignore
-  private eventTask: Promise<void>;
-
-  constructor(public transport: Transport, startEventLoop: boolean) {
+  constructor(public transport: Transport) {
     super();
     this.rpc = new RawClient(this.transport);
-    if (startEventLoop) {
-      this.eventTask = this.eventLoop();
-    }
-  }
+    this.transport.on("request", (request: Request) => {
+      const method = request.method;
+      if (method === "event") {
+        const event = request.params! as DCWireEvent<Event>;
+	//@ts-ignore
+        this.emit(event.event.type, event.contextId, event.event as any);
+        this.emit("ALL", event.contextId, event.event as any);
 
-  async eventLoop(): Promise<void> {
-    while (true) {
-      const event = await this.rpc.getNextEvent();
-      //@ts-ignore
-      this.emit(event.event.kind, event.contextId, event.event);
-      this.emit("ALL", event.contextId, event.event);
-
-      if (this.contextEmitters[event.contextId]) {
-        this.contextEmitters[event.contextId].emit(
-          event.event.kind,
-          //@ts-ignore
-          event.event as any
-        );
-        this.contextEmitters[event.contextId].emit("ALL", event.event as any);
+        if (this.contextEmitters[event.contextId]) {
+          this.contextEmitters[event.contextId].emit(
+            event.event.type,
+            //@ts-ignore
+            event.event as any
+          );
+          this.contextEmitters[event.contextId].emit("ALL", event.event);
+        }
       }
-    }
+    });
   }
 
   async listAccounts(): Promise<T.Account[]> {
@@ -76,12 +75,10 @@ export class BaseDeltaChat<
 
 export type Opts = {
   url: string;
-  startEventLoop: boolean;
 };
 
 export const DEFAULT_OPTS: Opts = {
   url: "ws://localhost:20808/ws",
-  startEventLoop: true,
 };
 export class DeltaChat extends BaseDeltaChat<WebsocketTransport> {
   opts: Opts;
@@ -89,24 +86,20 @@ export class DeltaChat extends BaseDeltaChat<WebsocketTransport> {
     this.transport.close();
   }
   constructor(opts?: Opts | string) {
-    if (typeof opts === "string") {
-      opts = { ...DEFAULT_OPTS, url: opts };
-    } else if (opts) {
-      opts = { ...DEFAULT_OPTS, ...opts };
-    } else {
-      opts = { ...DEFAULT_OPTS };
-    }
+    if (typeof opts === "string") opts = { url: opts };
+    if (opts) opts = { ...DEFAULT_OPTS, ...opts };
+    else opts = { ...DEFAULT_OPTS };
     const transport = new WebsocketTransport(opts.url);
-    super(transport, opts.startEventLoop);
+    super(transport);
     this.opts = opts;
   }
 }
 
 export class StdioDeltaChat extends BaseDeltaChat<StdioTransport> {
   close() {}
-  constructor(input: any, output: any, startEventLoop: boolean) {
+  constructor(input: any, output: any) {
     const transport = new StdioTransport(input, output);
-    super(transport, startEventLoop);
+    super(transport);
   }
 }
 
@@ -127,7 +120,7 @@ export class StdioTransport extends BaseTransport {
     });
   }
 
-  _send(message: any): void {
+  _send(message: RPC.Message): void {
     const serialized = JSON.stringify(message);
     this.input.write(serialized + "\n");
   }

deltachat-jsonrpc/typescript/src/lib.ts

@@ -1,5 +1,6 @@
 export * as RPC from "../generated/jsonrpc.js";
 export * as T from "../generated/types.js";
+export * from "../generated/events.js";
 export { RawClient } from "../generated/client.js";
 export * from "./client.js";
 export * as yerpc from "yerpc";

deltachat-jsonrpc/typescript/test/basic.ts

@@ -4,7 +4,10 @@ import chaiAsPromised from "chai-as-promised";
 chai.use(chaiAsPromised);
 import { StdioDeltaChat as DeltaChat } from "../deltachat.js";
 
-import { RpcServerHandle, startServer } from "./test_base.js";
+import {
+  RpcServerHandle,
+  startServer,
+} from "./test_base.js";
 
 describe("basic tests", () => {
   let serverHandle: RpcServerHandle;
@@ -12,9 +15,9 @@ describe("basic tests", () => {
 
   before(async () => {
     serverHandle = await startServer();
-    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout, true);
+    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout)
     // dc.on("ALL", (event) => {
-    //console.log("event", event);
+      //console.log("event", event);
     // });
   });
 
@@ -53,7 +56,7 @@ describe("basic tests", () => {
     ]);
   });
 
-  describe("account management", () => {
+  describe("account managment", () => {
     it("should create account", async () => {
       const res = await dc.rpc.addAccount();
       assert((await dc.rpc.getAllAccountIds()).length === 1);
@@ -73,15 +76,12 @@ describe("basic tests", () => {
     });
   });
 
-  describe("contact management", function () {
+  describe("contact managment", function () {
     let accountId: number;
     before(async () => {
       accountId = await dc.rpc.addAccount();
     });
     it("should block and unblock contact", async function () {
-      // Cannot send sync messages to self as we do not have a self address.
-      await dc.rpc.setConfig(accountId, "sync_msgs", "0");
-
       const contactId = await dc.rpc.createContact(
         accountId,
         "example@delta.chat",
@@ -106,44 +106,38 @@ describe("basic tests", () => {
       accountId = await dc.rpc.addAccount();
     });
 
-    it("set and retrieve", async function () {
+    it("set and retrive", async function () {
       await dc.rpc.setConfig(accountId, "addr", "valid@email");
       assert((await dc.rpc.getConfig(accountId, "addr")) == "valid@email");
     });
     it("set invalid key should throw", async function () {
-      await expect(dc.rpc.setConfig(accountId, "invalid_key", "some value")).to
-        .be.eventually.rejected;
+      await expect(dc.rpc.setConfig(accountId, "invalid_key", "some value")).to.be
+        .eventually.rejected;
     });
     it("get invalid key should throw", async function () {
       await expect(dc.rpc.getConfig(accountId, "invalid_key")).to.be.eventually
         .rejected;
     });
-    it("set and retrieve ui.*", async function () {
+    it("set and retrive ui.*", async function () {
       await dc.rpc.setConfig(accountId, "ui.chat_bg", "color:red");
       assert((await dc.rpc.getConfig(accountId, "ui.chat_bg")) == "color:red");
     });
-    it("set and retrieve (batch)", async function () {
+    it("set and retrive (batch)", async function () {
       const config = { addr: "valid@email", mail_pw: "1234" };
       await dc.rpc.batchSetConfig(accountId, config);
-      const retrieved = await dc.rpc.batchGetConfig(
-        accountId,
-        Object.keys(config)
-      );
+      const retrieved = await dc.rpc.batchGetConfig(accountId, Object.keys(config));
       expect(retrieved).to.deep.equal(config);
     });
-    it("set and retrieve ui.* (batch)", async function () {
+    it("set and retrive ui.* (batch)", async function () {
       const config = {
         "ui.chat_bg": "color:green",
         "ui.enter_key_sends": "true",
       };
       await dc.rpc.batchSetConfig(accountId, config);
-      const retrieved = await dc.rpc.batchGetConfig(
-        accountId,
-        Object.keys(config)
-      );
+      const retrieved = await dc.rpc.batchGetConfig(accountId, Object.keys(config));
       expect(retrieved).to.deep.equal(config);
     });
-    it("set and retrieve mixed(ui and core) (batch)", async function () {
+    it("set and retrive mixed(ui and core) (batch)", async function () {
       const config = {
         "ui.chat_bg": "color:yellow",
         "ui.enter_key_sends": "false",
@@ -151,10 +145,7 @@ describe("basic tests", () => {
         mail_pw: "123456",
       };
       await dc.rpc.batchSetConfig(accountId, config);
-      const retrieved = await dc.rpc.batchGetConfig(
-        accountId,
-        Object.keys(config)
-      );
+      const retrieved = await dc.rpc.batchGetConfig(accountId, Object.keys(config));
       expect(retrieved).to.deep.equal(config);
     });
   });

deltachat-jsonrpc/typescript/test/online.ts

@@ -12,39 +12,39 @@ describe("online tests", function () {
   let accountId1: number, accountId2: number;
 
   before(async function () {
-    this.timeout(60000);
-    if (!process.env.CHATMAIL_DOMAIN) {
+    this.timeout(12000);
+    if (!process.env.DCC_NEW_TMP_EMAIL) {
       if (process.env.COVERAGE && !process.env.COVERAGE_OFFLINE) {
         console.error(
-          "CAN NOT RUN COVERAGE correctly: Missing CHATMAIL_DOMAIN environment variable!\n\n",
+          "CAN NOT RUN COVERAGE correctly: Missing DCC_NEW_TMP_EMAIL environment variable!\n\n",
           "You can set COVERAGE_OFFLINE=1 to circumvent this check and skip the online tests, but those coverage results will be wrong, because some functions can only be tested in the online test"
         );
         process.exit(1);
       }
       console.log(
-        "Missing CHATMAIL_DOMAIN environment variable!, skip integration tests"
+        "Missing DCC_NEW_TMP_EMAIL environment variable!, skip intergration tests"
       );
       this.skip();
     }
     serverHandle = await startServer();
-    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout, true);
+    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout);
 
-    dc.on("ALL", (contextId, { kind }) => {
-      if (kind !== "Info") console.log(contextId, kind);
+    dc.on("ALL", (contextId, { type }) => {
+      if (type !== "Info") console.log(contextId, type);
     });
 
-    account1 = createTempUser(process.env.CHATMAIL_DOMAIN);
+    account1 = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
     if (!account1 || !account1.email || !account1.password) {
       console.log(
-        "We didn't got back an account from the api, skip integration tests"
+        "We didn't got back an account from the api, skip intergration tests"
       );
       this.skip();
     }
 
-    account2 = createTempUser(process.env.CHATMAIL_DOMAIN);
+    account2 = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
     if (!account2 || !account2.email || !account2.password) {
       console.log(
-        "We didn't got back an account2 from the api, skip integration tests"
+        "We didn't got back an account2 from the api, skip intergration tests"
       );
       this.skip();
     }
@@ -74,7 +74,7 @@ describe("online tests", function () {
     accountsConfigured = true;
   });
 
-  it("send and receive text message", async function () {
+  it("send and recieve text message", async function () {
     if (!accountsConfigured) {
       this.skip();
     }
@@ -97,8 +97,7 @@ describe("online tests", function () {
     const messageList = await dc.rpc.getMessageIds(
       accountId2,
       chatIdOnAccountB,
-      false,
-      false
+      0
     );
 
     expect(messageList).have.length(1);
@@ -106,7 +105,7 @@ describe("online tests", function () {
     expect(message.text).equal("Hello");
   });
 
-  it("send and receive text message roundtrip, encrypted on answer onwards", async function () {
+  it("send and recieve text message roundtrip, encrypted on answer onwards", async function () {
     if (!accountsConfigured) {
       this.skip();
     }
@@ -134,8 +133,7 @@ describe("online tests", function () {
     const messageList = await dc.rpc.getMessageIds(
       accountId2,
       chatIdOnAccountB,
-      false,
-      false
+      0
     );
     const message = await dc.rpc.getMessage(
       accountId2,
@@ -148,11 +146,11 @@ describe("online tests", function () {
       waitForEvent(dc, "IncomingMsg", accountId1),
     ]);
     dc.rpc.miscSendTextMessage(accountId2, chatId, "super secret message");
-    // Check if answer arrives at A and if it is encrypted
+    // Check if answer arives at A and if it is encrypted
     await eventPromise2;
 
     const messageId = (
-      await dc.rpc.getMessageIds(accountId1, chatId, false, false)
+      await dc.rpc.getMessageIds(accountId1, chatId, 0)
     ).reverse()[0];
     const message2 = await dc.rpc.getMessage(accountId1, messageId);
     expect(message2.text).equal("super secret message");
@@ -177,12 +175,12 @@ describe("online tests", function () {
   });
 });
 
-async function waitForEvent<T extends DcEvent["kind"]>(
+async function waitForEvent<T extends DcEvent["type"]>(
   dc: DeltaChat,
   eventType: T,
   accountId: number,
   timeout: number = EVENT_TIMEOUT
-): Promise<Extract<DcEvent, { kind: T }>> {
+): Promise<Extract<DcEvent, { type: T }>> {
   return new Promise((resolve, reject) => {
     const rejectTimeout = setTimeout(
       () => reject(new Error("Timeout reached before event came in")),

deltachat-jsonrpc/typescript/test/test_base.ts

@@ -2,6 +2,7 @@ import { tmpdir } from "os";
 import { join, resolve } from "path";
 import { mkdtemp, rm } from "fs/promises";
 import { spawn, exec } from "child_process";
+import fetch from "node-fetch";
 import { Readable, Writable } from "node:stream";
 
 export type RpcServerHandle = {
@@ -56,14 +57,15 @@ export async function startServer(): Promise<RpcServerHandle> {
   };
 }
 
-export function createTempUser(chatmailDomain: String) {
-  const charset = "2345789acdefghjkmnpqrstuvwxyz";
-  let user = "ci-";
-  for (let i = 0; i < 6; i++) {
-    user += charset[Math.floor(Math.random() * charset.length)];
-  }
-  const email = user + "@" + chatmailDomain;
-  return { email: email, password: user + "$" + user };
+export async function createTempUser(url: string) {
+  const response = await fetch(url, {
+    method: "POST", 
+    headers: {
+      "cache-control": "no-cache",
+    },
+  });
+  if (!response.ok) throw new Error('Received invalid response')
+  return response.json(); 
 }
 
 function getTargetDir(): Promise<string> {
@@ -87,3 +89,4 @@ function getTargetDir(): Promise<string> {
     );
   });
 }
+

deltachat-ratelimit/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "ratelimit"
-version = "1.0.0"
-description = "Token bucket implementation"
-edition = "2021"
-license = "MPL-2.0"
-
-[dependencies]

deltachat-repl/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "deltachat-repl"
-version = "1.131.5"
-license = "MPL-2.0"
-edition = "2021"
-
-[dependencies]
-ansi_term = "0.12.1"
-anyhow = "1"
-deltachat = { path = "..", features = ["internals"]}
-dirs = "5"
-log = "0.4.20"
-pretty_env_logger = "0.5"
-rusqlite = "0.30"
-rustyline = "12"
-tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
-
-[features]
-default = ["vendored"]
-vendored = ["deltachat/vendored"]

deltachat-rpc-client/LICENSE

@@ -1,373 +0,0 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
-    means each individual or legal entity that creates, contributes to
-    the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-    means the combination of the Contributions of others (if any) used
-    by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-    means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-    means Source Code Form to which the initial Contributor has attached
-    the notice in Exhibit A, the Executable Form of such Source Code
-    Form, and Modifications of such Source Code Form, in each case
-    including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-    means
-
-    (a) that the initial Contributor has attached the notice described
-        in Exhibit B to the Covered Software; or
-
-    (b) that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the
-        terms of a Secondary License.
-
-1.6. "Executable Form"
-    means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-    means a work that combines Covered Software with other material, in
-    a separate file or files, that is not Covered Software.
-
-1.8. "License"
-    means this document.
-
-1.9. "Licensable"
-    means having the right to grant, to the maximum extent possible,
-    whether at the time of the initial grant or subsequently, any and
-    all of the rights conveyed by this License.
-
-1.10. "Modifications"
-    means any of the following:
-
-    (a) any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered
-        Software; or
-
-    (b) any new file in Source Code Form that contains any Covered
-        Software.
-
-1.11. "Patent Claims" of a Contributor
-    means any patent claim(s), including without limitation, method,
-    process, and apparatus claims, in any patent Licensable by such
-    Contributor that would be infringed, but for the grant of the
-    License, by the making, using, selling, offering for sale, having
-    made, import, or transfer of either its Contributions or its
-    Contributor Version.
-
-1.12. "Secondary License"
-    means either the GNU General Public License, Version 2.0, the GNU
-    Lesser General Public License, Version 2.1, the GNU Affero General
-    Public License, Version 3.0, or any later versions of those
-    licenses.
-
-1.13. "Source Code Form"
-    means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-    means an individual or a legal entity exercising rights under this
-    License. For legal entities, "You" includes any entity that
-    controls, is controlled by, or is under common control with You. For
-    purposes of this definition, "control" means (a) the power, direct
-    or indirect, to cause the direction or management of such entity,
-    whether by contract or otherwise, or (b) ownership of more than
-    fifty percent (50%) of the outstanding shares or beneficial
-    ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
-    Licensable by such Contributor to use, reproduce, make available,
-    modify, display, perform, distribute, and otherwise exploit its
-    Contributions, either on an unmodified basis, with Modifications, or
-    as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
-    for sale, have made, import, and otherwise transfer either its
-    Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
-    or
-
-(b) for infringements caused by: (i) Your and any other third party's
-    modifications of Covered Software, or (ii) the combination of its
-    Contributions with other software (except as part of its Contributor
-    Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
-    its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
-    Form, as described in Section 3.1, and You must inform recipients of
-    the Executable Form how they can obtain a copy of such Source Code
-    Form by reasonable means in a timely manner, at a charge no more
-    than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
-    License, or sublicense it under different terms, provided that the
-    license for the Executable Form does not attempt to limit or alter
-    the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-*                                                                      *
-*  6. Disclaimer of Warranty                                           *
-*  -------------------------                                           *
-*                                                                      *
-*  Covered Software is provided under this License on an "as is"       *
-*  basis, without warranty of any kind, either expressed, implied, or  *
-*  statutory, including, without limitation, warranties that the       *
-*  Covered Software is free of defects, merchantable, fit for a        *
-*  particular purpose or non-infringing. The entire risk as to the     *
-*  quality and performance of the Covered Software is with You.        *
-*  Should any Covered Software prove defective in any respect, You     *
-*  (not any Contributor) assume the cost of any necessary servicing,   *
-*  repair, or correction. This disclaimer of warranty constitutes an   *
-*  essential part of this License. No use of any Covered Software is   *
-*  authorized under this License except under this disclaimer.         *
-*                                                                      *
-************************************************************************
-
-************************************************************************
-*                                                                      *
-*  7. Limitation of Liability                                          *
-*  --------------------------                                          *
-*                                                                      *
-*  Under no circumstances and under no legal theory, whether tort      *
-*  (including negligence), contract, or otherwise, shall any           *
-*  Contributor, or anyone who distributes Covered Software as          *
-*  permitted above, be liable to You for any direct, indirect,         *
-*  special, incidental, or consequential damages of any character      *
-*  including, without limitation, damages for lost profits, loss of    *
-*  goodwill, work stoppage, computer failure or malfunction, or any    *
-*  and all other commercial damages or losses, even if such party      *
-*  shall have been informed of the possibility of such damages. This   *
-*  limitation of liability shall not apply to liability for death or   *
-*  personal injury resulting from such party's negligence to the       *
-*  extent applicable law prohibits such limitation. Some               *
-*  jurisdictions do not allow the exclusion or limitation of           *
-*  incidental or consequential damages, so this exclusion and          *
-*  limitation may not apply to You.                                    *
-*                                                                      *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
-  This Source Code Form is subject to the terms of the Mozilla Public
-  License, v. 2.0. If a copy of the MPL was not distributed with this
-  file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
-  This Source Code Form is "Incompatible With Secondary Licenses", as
-  defined by the Mozilla Public License, v. 2.0.

deltachat-rpc-client/README.md

@@ -5,27 +5,13 @@ and provides asynchronous interface to it.
 
 ## Getting started
 
-To use Delta Chat RPC client, first build a `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`
-or download a prebuilt release.
+To use Delta Chat RPC client, first build a `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`.
 Install it anywhere in your `PATH`.
 
-[Create a virtual environment](https://docs.python.org/3/library/venv.html)
-if you don't have one already and activate it.
-```
-$ python -m venv env
-$ . env/bin/activate
-```
-
-Install `deltachat-rpc-client` from source:
-```
-$ cd deltachat-rpc-client
-$ pip install .
-```
-
 ## Testing
 
 1. Build `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`.
-2. Run `CHATMAIL_DOMAIN=nine.testrun.org PATH="../target/debug:$PATH" tox`.
+2. Run `PATH="../target/debug:$PATH" tox`.
 
 Additional arguments to `tox` are passed to pytest, e.g. `tox -- -s` does not capture test output.
 
@@ -37,14 +23,19 @@ $ tox --devenv env
 $ . env/bin/activate
 ```
 
+It is recommended to use IPython, because it supports using `await` directly
+from the REPL.
+
 ```
-$ python
->>> from deltachat_rpc_client import *
->>> rpc = Rpc()
->>> rpc.start()
->>> dc = DeltaChat(rpc)
->>> system_info = dc.get_system_info()
->>> system_info["level"]
-'awesome'
->>> rpc.close()
+$ pip install ipython
+$ PATH="../target/debug:$PATH" ipython
+...
+In [1]: from deltachat_rpc_client import *
+In [2]: rpc = Rpc()
+In [3]: await rpc.start()
+In [4]: dc = DeltaChat(rpc)
+In [5]: system_info = await dc.get_system_info()
+In [6]: system_info["level"]
+Out[6]: 'awesome'
+In [7]: await rpc.close()
 ```

deltachat-rpc-client/examples/echobot.py

@@ -4,21 +4,22 @@
 it will echo back any text send to it, it also will print to console all Delta Chat core events.
 Pass --help to the CLI to see available options.
 """
+import asyncio
+
 from deltachat_rpc_client import events, run_bot_cli
 
 hooks = events.HookCollection()
 
 
 @hooks.on(events.RawEvent)
-def log_event(event):
+async def log_event(event):
     print(event)
 
 
 @hooks.on(events.NewMessage)
-def echo(event):
-    snapshot = event.message_snapshot
-    snapshot.chat.send_text(snapshot.text)
+async def echo(msg):
+    await msg.chat.send_text(msg.text)
 
 
 if __name__ == "__main__":
-    run_bot_cli(hooks)
+    asyncio.run(run_bot_cli(hooks))

deltachat-rpc-client/examples/echobot_advanced.py

@@ -3,9 +3,9 @@
 
 it will echo back any message that has non-empty text and also supports the /help command.
 """
+import asyncio
 import logging
 import sys
-from threading import Thread
 
 from deltachat_rpc_client import Bot, DeltaChat, EventType, Rpc, events
 
@@ -13,62 +13,43 @@ hooks = events.HookCollection()
 
 
 @hooks.on(events.RawEvent)
-def log_event(event):
-    if event.kind == EventType.INFO:
+async def log_event(event):
+    if event.type == EventType.INFO:
         logging.info(event.msg)
-    elif event.kind == EventType.WARNING:
+    elif event.type == EventType.WARNING:
         logging.warning(event.msg)
 
 
 @hooks.on(events.RawEvent(EventType.ERROR))
-def log_error(event):
+async def log_error(event):
     logging.error(event.msg)
 
 
-@hooks.on(events.MemberListChanged)
-def on_memberlist_changed(event):
-    logging.info("member %s was %s", event.member, "added" if event.member_added else "removed")
+@hooks.on(events.NewMessage(r".+", func=lambda msg: not msg.text.startswith("/")))
+async def echo(msg):
+    await msg.chat.send_text(msg.text)
 
 
-@hooks.on(events.GroupImageChanged)
-def on_group_image_changed(event):
-    logging.info("group image %s", "deleted" if event.image_deleted else "changed")
+@hooks.on(events.NewMessage(r"/help"))
+async def help_command(msg):
+    await msg.chat.send_text("Send me any text message and I will echo it back")
 
 
-@hooks.on(events.GroupNameChanged)
-def on_group_name_changed(event):
-    logging.info("group name changed, old name: %s", event.old_name)
-
-
-@hooks.on(events.NewMessage(func=lambda e: not e.command))
-def echo(event):
-    snapshot = event.message_snapshot
-    if snapshot.text or snapshot.file:
-        snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
-
-
-@hooks.on(events.NewMessage(command="/help"))
-def help_command(event):
-    snapshot = event.message_snapshot
-    snapshot.chat.send_text("Send me any message and I will echo it back")
-
-
-def main():
-    with Rpc() as rpc:
+async def main():
+    async with Rpc() as rpc:
         deltachat = DeltaChat(rpc)
-        system_info = deltachat.get_system_info()
+        system_info = await deltachat.get_system_info()
         logging.info("Running deltachat core %s", system_info.deltachat_core_version)
 
-        accounts = deltachat.get_all_accounts()
-        account = accounts[0] if accounts else deltachat.add_account()
+        accounts = await deltachat.get_all_accounts()
+        account = accounts[0] if accounts else await deltachat.add_account()
 
         bot = Bot(account, hooks)
-        if not bot.is_configured():
-            configure_thread = Thread(run=bot.configure, kwargs={"email": sys.argv[1], "password": sys.argv[2]})
-            configure_thread.start()
-        bot.run_forever()
+        if not await bot.is_configured():
+            asyncio.create_task(bot.configure(email=sys.argv[1], password=sys.argv[2]))
+        await bot.run_forever()
 
 
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
-    main()
+    asyncio.run(main())

deltachat-rpc-client/examples/echobot_no_hooks.py

@@ -2,44 +2,45 @@
 """
 Example echo bot without using hooks
 """
+import asyncio
 import logging
 import sys
 
-from deltachat_rpc_client import DeltaChat, EventType, Rpc, SpecialContactId
+from deltachat_rpc_client import DeltaChat, EventType, Rpc
 
 
-def main():
-    with Rpc() as rpc:
+async def main():
+    async with Rpc() as rpc:
         deltachat = DeltaChat(rpc)
-        system_info = deltachat.get_system_info()
+        system_info = await deltachat.get_system_info()
         logging.info("Running deltachat core %s", system_info["deltachat_core_version"])
 
-        accounts = deltachat.get_all_accounts()
-        account = accounts[0] if accounts else deltachat.add_account()
+        accounts = await deltachat.get_all_accounts()
+        account = accounts[0] if accounts else await deltachat.add_account()
 
-        account.set_config("bot", "1")
-        if not account.is_configured():
+        await account.set_config("bot", "1")
+        if not await account.is_configured():
             logging.info("Account is not configured, configuring")
-            account.set_config("addr", sys.argv[1])
-            account.set_config("mail_pw", sys.argv[2])
-            account.configure()
+            await account.set_config("addr", sys.argv[1])
+            await account.set_config("mail_pw", sys.argv[2])
+            await account.configure()
             logging.info("Configured")
         else:
             logging.info("Account is already configured")
-            deltachat.start_io()
+            await deltachat.start_io()
 
-        def process_messages():
-            for message in account.get_next_messages():
-                snapshot = message.get_snapshot()
-                if snapshot.from_id != SpecialContactId.SELF and not snapshot.is_bot and not snapshot.is_info:
-                    snapshot.chat.send_text(snapshot.text)
-                snapshot.message.mark_seen()
+        async def process_messages():
+            for message in await account.get_fresh_messages_in_arrival_order():
+                snapshot = await message.get_snapshot()
+                if not snapshot.is_info:
+                    await snapshot.chat.send_text(snapshot.text)
+                await snapshot.message.mark_seen()
 
         # Process old messages.
-        process_messages()
+        await process_messages()
 
         while True:
-            event = account.wait_for_event()
+            event = await account.wait_for_event()
             if event["type"] == EventType.INFO:
                 logging.info("%s", event["msg"])
             elif event["type"] == EventType.WARNING:
@@ -48,9 +49,9 @@ def main():
                 logging.error("%s", event["msg"])
             elif event["type"] == EventType.INCOMING_MSG:
                 logging.info("Got an incoming message")
-                process_messages()
+                await process_messages()
 
 
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
-    main()
+    asyncio.run(main())

deltachat-rpc-client/pyproject.toml

@@ -5,24 +5,21 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "deltachat-rpc-client"
 description = "Python client for Delta Chat core JSON-RPC interface"
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
-    "Operating System :: POSIX :: Linux",
-    "Operating System :: MacOS :: MacOS X",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Topic :: Communications :: Chat",
-    "Topic :: Communications :: Email"
+dependencies = [
+    "aiohttp",
+    "aiodns"
 ]
 dynamic = [
     "version"
 ]
 
+[tool.setuptools]
+# We declare the package not-zip-safe so that our type hints are also available
+# when checking client code that uses our (installed) package.
+# Ref:
+# https://mypy.readthedocs.io/en/stable/installed_packages.html?highlight=zip#using-installed-packages-with-mypy-pep-561
+zip-safe = false
+
 [tool.setuptools.package-data]
 deltachat_rpc_client = [
     "py.typed"
@@ -30,44 +27,3 @@ deltachat_rpc_client = [
 
 [project.entry-points.pytest11]
 "deltachat_rpc_client.pytestplugin" = "deltachat_rpc_client.pytestplugin"
-
-[tool.setuptools_scm]
-root = ".."
-
-[tool.black]
-line-length = 120
-
-[tool.ruff]
-select = [
-  "E", "W", # pycodestyle
-  "F", # Pyflakes
-  "N", # pep8-naming
-  "I", # isort
-
-  "ARG", # flake8-unused-arguments
-  "B", # flake8-bugbear
-  "C4", # flake8-comprehensions
-  "COM", # flake8-commas
-  "DTZ", # flake8-datetimez
-  "ICN", # flake8-import-conventions
-  "ISC", # flake8-implicit-str-concat
-  "PIE", # flake8-pie
-  "PT", # flake8-pytest-style
-  "RET", # flake8-return
-  "SIM", # flake8-simplify
-  "TCH", # flake8-type-checking
-  "TID", # flake8-tidy-imports
-  "YTT", # flake8-2020
-
-  "ERA", # eradicate
-
-  "PLC", # Pylint Convention
-  "PLE", # Pylint Error
-  "PLW", # Pylint Warning
-
-  "RUF006" # asyncio-dangling-task
-]
-line-length = 120
-
-[tool.isort]
-profile = "black"

deltachat-rpc-client/src/deltachat_rpc_client/__init__.py

@@ -1,26 +1,10 @@
-"""Delta Chat JSON-RPC high-level API"""
-from ._utils import AttrDict, run_bot_cli, run_client_cli
+"""Delta Chat asynchronous high-level API"""
 from .account import Account
 from .chat import Chat
 from .client import Bot, Client
-from .const import EventType, SpecialContactId
+from .const import EventType
 from .contact import Contact
 from .deltachat import DeltaChat
 from .message import Message
 from .rpc import Rpc
-
-__all__ = [
-    "Account",
-    "AttrDict",
-    "Bot",
-    "Chat",
-    "Client",
-    "Contact",
-    "DeltaChat",
-    "EventType",
-    "Message",
-    "SpecialContactId",
-    "Rpc",
-    "run_bot_cli",
-    "run_client_cli",
-]
+from .utils import AttrDict, run_bot_cli, run_client_cli

deltachat-rpc-client/src/deltachat_rpc_client/_utils.py

@@ -1,170 +0,0 @@
-import argparse
-import re
-import sys
-from threading import Thread
-from typing import TYPE_CHECKING, Callable, Iterable, Optional, Tuple, Type, Union
-
-if TYPE_CHECKING:
-    from .client import Client
-    from .events import EventFilter
-
-
-def _camel_to_snake(name: str) -> str:
-    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
-    name = re.sub("__([A-Z])", r"_\1", name)
-    name = re.sub("([a-z0-9])([A-Z])", r"\1_\2", name)
-    return name.lower()
-
-
-def _to_attrdict(obj):
-    if isinstance(obj, AttrDict):
-        return obj
-    if isinstance(obj, dict):
-        return AttrDict(obj)
-    if isinstance(obj, list):
-        return [_to_attrdict(elem) for elem in obj]
-    return obj
-
-
-class AttrDict(dict):
-    """Dictionary that allows accessing values using the "dot notation" as attributes."""
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__({_camel_to_snake(key): _to_attrdict(value) for key, value in dict(*args, **kwargs).items()})
-
-    def __getattr__(self, attr):
-        if attr in self:
-            return self[attr]
-        raise AttributeError("Attribute not found: " + str(attr))
-
-    def __setattr__(self, attr, val):
-        if attr in self:
-            raise AttributeError("Attribute-style access is read only")
-        super().__setattr__(attr, val)
-
-
-def run_client_cli(
-    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
-    argv: Optional[list] = None,
-    **kwargs,
-) -> None:
-    """Run a simple command line app, using the given hooks.
-
-    Extra keyword arguments are passed to the internal Rpc object.
-    """
-    from .client import Client
-
-    _run_cli(Client, hooks, argv, **kwargs)
-
-
-def run_bot_cli(
-    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
-    argv: Optional[list] = None,
-    **kwargs,
-) -> None:
-    """Run a simple bot command line using the given hooks.
-
-    Extra keyword arguments are passed to the internal Rpc object.
-    """
-    from .client import Bot
-
-    _run_cli(Bot, hooks, argv, **kwargs)
-
-
-def _run_cli(
-    client_type: Type["Client"],
-    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
-    argv: Optional[list] = None,
-    **kwargs,
-) -> None:
-    from .deltachat import DeltaChat
-    from .rpc import Rpc
-
-    if argv is None:
-        argv = sys.argv
-
-    parser = argparse.ArgumentParser(prog=argv[0] if argv else None)
-    parser.add_argument(
-        "accounts_dir",
-        help="accounts folder (default: current working directory)",
-        nargs="?",
-    )
-    parser.add_argument("--email", action="store", help="email address")
-    parser.add_argument("--password", action="store", help="password")
-    args = parser.parse_args(argv[1:])
-
-    with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
-        deltachat = DeltaChat(rpc)
-        core_version = (deltachat.get_system_info()).deltachat_core_version
-        accounts = deltachat.get_all_accounts()
-        account = accounts[0] if accounts else deltachat.add_account()
-
-        client = client_type(account, hooks)
-        client.logger.debug("Running deltachat core %s", core_version)
-        if not client.is_configured():
-            assert args.email, "Account is not configured and email must be provided"
-            assert args.password, "Account is not configured and password must be provided"
-            configure_thread = Thread(run=client.configure, kwargs={"email": args.email, "password": args.password})
-            configure_thread.start()
-        client.run_forever()
-
-
-def extract_addr(text: str) -> str:
-    """extract email address from the given text."""
-    match = re.match(r".*\((.+@.+)\)", text)
-    if match:
-        text = match.group(1)
-    text = text.rstrip(".")
-    return text.strip()
-
-
-def parse_system_image_changed(text: str) -> Optional[Tuple[str, bool]]:
-    """return image changed/deleted info from parsing the given system message text."""
-    text = text.lower()
-    match = re.match(r"group image (changed|deleted) by (.+).", text)
-    if match:
-        action, actor = match.groups()
-        return (extract_addr(actor), action == "deleted")
-    return None
-
-
-def parse_system_title_changed(text: str) -> Optional[Tuple[str, str]]:
-    text = text.lower()
-    match = re.match(r'group name changed from "(.+)" to ".+" by (.+).', text)
-    if match:
-        old_title, actor = match.groups()
-        return (extract_addr(actor), old_title)
-    return None
-
-
-def parse_system_add_remove(text: str) -> Optional[Tuple[str, str, str]]:
-    """return add/remove info from parsing the given system message text.
-
-    returns a (action, affected, actor) tuple.
-    """
-    # You removed member a@b.
-    # You added member a@b.
-    # Member Me (x@y) removed by a@b.
-    # Member x@y added by a@b
-    # Member With space (tmp1@x.org) removed by tmp2@x.org.
-    # Member With space (tmp1@x.org) removed by Another member (tmp2@x.org).",
-    # Group left by some one (tmp1@x.org).
-    # Group left by tmp1@x.org.
-    text = text.lower()
-
-    match = re.match(r"member (.+) (removed|added) by (.+)", text)
-    if match:
-        affected, action, actor = match.groups()
-        return action, extract_addr(affected), extract_addr(actor)
-
-    match = re.match(r"you (removed|added) member (.+)", text)
-    if match:
-        action, affected = match.groups()
-        return action, extract_addr(affected), "me"
-
-    if text.startswith("group left by "):
-        addr = extract_addr(text[13:])
-        if addr:
-            return "removed", addr, addr
-
-    return None

deltachat-rpc-client/src/deltachat_rpc_client/account.py

@@ -1,86 +1,97 @@
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, List, Optional, Tuple, Union
-from warnings import warn
 
-from ._utils import AttrDict
 from .chat import Chat
-from .const import ChatlistFlag, ContactFlag, EventType, SpecialContactId
+from .const import ChatlistFlag, ContactFlag, SpecialContactId
 from .contact import Contact
 from .message import Message
+from .rpc import Rpc
+from .utils import AttrDict
 
 if TYPE_CHECKING:
     from .deltachat import DeltaChat
-    from .rpc import Rpc
 
 
-@dataclass
 class Account:
     """Delta Chat account."""
 
-    manager: "DeltaChat"
-    id: int
+    def __init__(self, manager: "DeltaChat", account_id: int) -> None:
+        self.manager = manager
+        self.id = account_id
 
     @property
-    def _rpc(self) -> "Rpc":
+    def _rpc(self) -> Rpc:
         return self.manager.rpc
 
-    def wait_for_event(self) -> AttrDict:
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Account):
+            return False
+        return self.id == other.id and self.manager == other.manager
+
+    def __ne__(self, other) -> bool:
+        return not self == other
+
+    def __repr__(self) -> str:
+        return f"<Account id={self.id}>"
+
+    async def wait_for_event(self) -> AttrDict:
         """Wait until the next event and return it."""
-        return AttrDict(self._rpc.wait_for_event(self.id))
+        return AttrDict(await self._rpc.wait_for_event(self.id))
 
-    def remove(self) -> None:
+    async def remove(self) -> None:
         """Remove the account."""
-        self._rpc.remove_account(self.id)
+        await self._rpc.remove_account(self.id)
 
-    def start_io(self) -> None:
+    async def start_io(self) -> None:
         """Start the account I/O."""
-        self._rpc.start_io(self.id)
+        await self._rpc.start_io(self.id)
 
-    def stop_io(self) -> None:
+    async def stop_io(self) -> None:
         """Stop the account I/O."""
-        self._rpc.stop_io(self.id)
+        await self._rpc.stop_io(self.id)
 
-    def get_info(self) -> AttrDict:
+    async def get_info(self) -> AttrDict:
         """Return dictionary of this account configuration parameters."""
-        return AttrDict(self._rpc.get_info(self.id))
+        return AttrDict(await self._rpc.get_info(self.id))
 
-    def get_size(self) -> int:
+    async def get_size(self) -> int:
         """Get the combined filesize of an account in bytes."""
-        return self._rpc.get_account_file_size(self.id)
+        return await self._rpc.get_account_file_size(self.id)
 
-    def is_configured(self) -> bool:
+    async def is_configured(self) -> bool:
         """Return True if this account is configured."""
-        return self._rpc.is_configured(self.id)
+        return await self._rpc.is_configured(self.id)
 
-    def set_config(self, key: str, value: Optional[str] = None) -> None:
+    async def set_config(self, key: str, value: Optional[str] = None) -> None:
         """Set configuration value."""
-        self._rpc.set_config(self.id, key, value)
+        await self._rpc.set_config(self.id, key, value)
 
-    def get_config(self, key: str) -> Optional[str]:
+    async def get_config(self, key: str) -> Optional[str]:
         """Get configuration value."""
-        return self._rpc.get_config(self.id, key)
+        return await self._rpc.get_config(self.id, key)
 
-    def update_config(self, **kwargs) -> None:
+    async def update_config(self, **kwargs) -> None:
         """update config values."""
         for key, value in kwargs.items():
-            self.set_config(key, value)
+            await self.set_config(key, value)
 
-    def set_avatar(self, img_path: Optional[str] = None) -> None:
+    async def set_avatar(self, img_path: Optional[str] = None) -> None:
         """Set self avatar.
 
         Passing None will discard the currently set avatar.
         """
-        self.set_config("selfavatar", img_path)
+        await self.set_config("selfavatar", img_path)
 
-    def get_avatar(self) -> Optional[str]:
+    async def get_avatar(self) -> Optional[str]:
         """Get self avatar."""
-        return self.get_config("selfavatar")
+        return await self.get_config("selfavatar")
 
-    def configure(self) -> None:
+    async def configure(self) -> None:
         """Configure an account."""
-        self._rpc.configure(self.id)
+        await self._rpc.configure(self.id)
 
-    def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
+    async def create_contact(
+        self, obj: Union[int, str, Contact], name: Optional[str] = None
+    ) -> Contact:
         """Create a new Contact or return an existing one.
 
         Calling this method will always result in the same
@@ -94,38 +105,27 @@ class Account:
         if isinstance(obj, int):
             obj = Contact(self, obj)
         if isinstance(obj, Contact):
-            obj = obj.get_snapshot().address
-        return Contact(self, self._rpc.create_contact(self.id, obj, name))
+            obj = (await obj.get_snapshot()).address
+        return Contact(self, await self._rpc.create_contact(self.id, obj, name))
 
-    def get_contact_by_id(self, contact_id: int) -> Contact:
+    async def get_contact_by_id(self, contact_id: int) -> Contact:
         """Return Contact instance for the given contact ID."""
         return Contact(self, contact_id)
 
-    def get_contact_by_addr(self, address: str) -> Optional[Contact]:
+    async def get_contact_by_addr(self, address: str) -> Optional[Contact]:
         """Check if an e-mail address belongs to a known and unblocked contact."""
-        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
+        contact_id = await self._rpc.lookup_contact_id_by_addr(self.id, address)
         return contact_id and Contact(self, contact_id)
 
-    def get_blocked_contacts(self) -> List[AttrDict]:
+    async def get_blocked_contacts(self) -> List[AttrDict]:
         """Return a list with snapshots of all blocked contacts."""
-        contacts = self._rpc.get_blocked_contacts(self.id)
-        return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
+        contacts = await self._rpc.get_blocked_contacts(self.id)
+        return [
+            AttrDict(contact=Contact(self, contact["id"]), **contact)
+            for contact in contacts
+        ]
 
-    def get_chat_by_contact(self, contact: Union[int, Contact]) -> Optional[Chat]:
-        """Return 1:1 chat for a contact if it exists."""
-        if isinstance(contact, Contact):
-            assert contact.account == self
-            contact_id = contact.id
-        elif isinstance(contact, int):
-            contact_id = contact
-        else:
-            raise ValueError(f"{contact!r} is not a contact")
-        chat_id = self._rpc.get_chat_id_by_contact_id(self.id, contact_id)
-        if chat_id:
-            return Chat(self, chat_id)
-        return None
-
-    def get_contacts(
+    async def get_contacts(
         self,
         query: Optional[str] = None,
         with_self: bool = False,
@@ -147,9 +147,12 @@ class Account:
             flags |= ContactFlag.ADD_SELF
 
         if snapshot:
-            contacts = self._rpc.get_contacts(self.id, flags, query)
-            return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
-        contacts = self._rpc.get_contact_ids(self.id, flags, query)
+            contacts = await self._rpc.get_contacts(self.id, flags, query)
+            return [
+                AttrDict(contact=Contact(self, contact["id"]), **contact)
+                for contact in contacts
+            ]
+        contacts = await self._rpc.get_contact_ids(self.id, flags, query)
         return [Contact(self, contact_id) for contact_id in contacts]
 
     @property
@@ -157,7 +160,7 @@ class Account:
         """This account's identity as a Contact."""
         return Contact(self, SpecialContactId.SELF)
 
-    def get_chatlist(
+    async def get_chatlist(
         self,
         query: Optional[str] = None,
         contact: Optional[Contact] = None,
@@ -173,7 +176,7 @@ class Account:
         :param contact: if a contact is specified only chats including this contact are returned.
         :param archived_only: if True only archived chats are returned.
         :param for_forwarding: if True the chat list is sorted with "Saved messages" at the top
-                               and without "Device chat" and contact requests.
+                               and withot "Device chat" and contact requests.
         :param no_specials: if True archive link is not added to the list.
         :param alldone_hint: if True the "all done hint" special chat will be added to the list
                              as needed.
@@ -189,114 +192,74 @@ class Account:
         if alldone_hint:
             flags |= ChatlistFlag.ADD_ALLDONE_HINT
 
-        entries = self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
+        entries = await self._rpc.get_chatlist_entries(
+            self.id, flags, query, contact and contact.id
+        )
         if not snapshot:
-            return [Chat(self, entry) for entry in entries]
+            return [Chat(self, entry[0]) for entry in entries]
 
-        items = self._rpc.get_chatlist_items_by_entries(self.id, entries)
+        items = await self._rpc.get_chatlist_items_by_entries(self.id, entries)
         chats = []
         for item in items.values():
             item["chat"] = Chat(self, item["id"])
             chats.append(AttrDict(item))
         return chats
 
-    def create_group(self, name: str, protect: bool = False) -> Chat:
+    async def create_group(self, name: str, protect: bool = False) -> Chat:
         """Create a new group chat.
 
         After creation, the group has only self-contact as member and is in unpromoted state.
         """
-        return Chat(self, self._rpc.create_group_chat(self.id, name, protect))
+        return Chat(self, await self._rpc.create_group_chat(self.id, name, protect))
 
-    def get_chat_by_id(self, chat_id: int) -> Chat:
+    async def get_chat_by_id(self, chat_id: int) -> Chat:
         """Return the Chat instance with the given ID."""
         return Chat(self, chat_id)
 
-    def secure_join(self, qrdata: str) -> Chat:
+    async def secure_join(self, qrdata: str) -> Chat:
         """Continue a Setup-Contact or Verified-Group-Invite protocol started on
         another device.
 
         The function returns immediately and the handshake runs in background, sending
         and receiving several messages.
         Subsequent calls of `secure_join()` will abort previous, unfinished handshakes.
-        See https://securejoin.readthedocs.io/en/latest/new.html for protocol details.
+        See https://countermitm.readthedocs.io/en/latest/new.html for protocol details.
 
         :param qrdata: The text of the scanned QR code.
         """
-        return Chat(self, self._rpc.secure_join(self.id, qrdata))
+        return Chat(self, await self._rpc.secure_join(self.id, qrdata))
 
-    def get_qr_code(self) -> Tuple[str, str]:
+    async def get_qr_code(self) -> Tuple[str, str]:
         """Get Setup-Contact QR Code text and SVG data.
 
         this data needs to be transferred to another Delta Chat account
         in a second channel, typically used by mobiles with QRcode-show + scan UX.
         """
-        return self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
+        return await self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
 
-    def get_message_by_id(self, msg_id: int) -> Message:
+    async def get_message_by_id(self, msg_id: int) -> Message:
         """Return the Message instance with the given ID."""
         return Message(self, msg_id)
 
-    def mark_seen_messages(self, messages: List[Message]) -> None:
+    async def mark_seen_messages(self, messages: List[Message]) -> None:
         """Mark the given set of messages as seen."""
-        self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
+        await self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
 
-    def delete_messages(self, messages: List[Message]) -> None:
+    async def delete_messages(self, messages: List[Message]) -> None:
         """Delete messages (local and remote)."""
-        self._rpc.delete_messages(self.id, [msg.id for msg in messages])
+        await self._rpc.delete_messages(self.id, [msg.id for msg in messages])
 
-    def get_fresh_messages(self) -> List[Message]:
+    async def get_fresh_messages(self) -> List[Message]:
         """Return the list of fresh messages, newest messages first.
 
         This call is intended for displaying notifications.
         If you are writing a bot, use `get_fresh_messages_in_arrival_order()` instead,
         to process oldest messages first.
         """
-        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
+        fresh_msg_ids = await self._rpc.get_fresh_msgs(self.id)
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
 
-    def get_next_messages(self) -> List[Message]:
-        """Return a list of next messages."""
-        next_msg_ids = self._rpc.get_next_msgs(self.id)
-        return [Message(self, msg_id) for msg_id in next_msg_ids]
-
-    def wait_next_messages(self) -> List[Message]:
-        """Wait for new messages and return a list of them."""
-        next_msg_ids = self._rpc.wait_next_msgs(self.id)
-        return [Message(self, msg_id) for msg_id in next_msg_ids]
-
-    def wait_for_incoming_msg_event(self):
-        """Wait for incoming message event and return it."""
-        while True:
-            event = self.wait_for_event()
-            if event.kind == EventType.INCOMING_MSG:
-                return event
-
-    def wait_for_securejoin_inviter_success(self):
-        while True:
-            event = self.wait_for_event()
-            if event["kind"] == "SecurejoinInviterProgress" and event["progress"] == 1000:
-                break
-
-    def wait_for_securejoin_joiner_success(self):
-        while True:
-            event = self.wait_for_event()
-            if event["kind"] == "SecurejoinJoinerProgress" and event["progress"] == 1000:
-                break
-
-    def get_fresh_messages_in_arrival_order(self) -> List[Message]:
+    async def get_fresh_messages_in_arrival_order(self) -> List[Message]:
         """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
-        warn(
-            "get_fresh_messages_in_arrival_order is deprecated, use get_next_messages instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        fresh_msg_ids = sorted(self._rpc.get_fresh_msgs(self.id))
+        fresh_msg_ids = sorted(await self._rpc.get_fresh_msgs(self.id))
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
-
-    def export_backup(self, path, passphrase: str = "") -> None:
-        """Export backup."""
-        self._rpc.export_backup(self.id, str(path), passphrase)
-
-    def import_backup(self, path, passphrase: str = "") -> None:
-        """Import backup."""
-        self._rpc.import_backup(self.id, str(path), passphrase)

deltachat-rpc-client/src/deltachat_rpc_client/chat.py

@@ -1,31 +1,40 @@
 import calendar
-from dataclasses import dataclass
+from datetime import datetime
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
 
-from ._utils import AttrDict
-from .const import ChatVisibility, ViewType
+from .const import ChatVisibility
 from .contact import Contact
 from .message import Message
+from .rpc import Rpc
+from .utils import AttrDict
 
 if TYPE_CHECKING:
-    from datetime import datetime
-
     from .account import Account
-    from .rpc import Rpc
 
 
-@dataclass
 class Chat:
     """Chat object which manages members and through which you can send and retrieve messages."""
 
-    account: "Account"
-    id: int
+    def __init__(self, account: "Account", chat_id: int) -> None:
+        self.account = account
+        self.id = chat_id
 
     @property
-    def _rpc(self) -> "Rpc":
+    def _rpc(self) -> Rpc:
         return self.account._rpc
 
-    def delete(self) -> None:
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Chat):
+            return False
+        return self.id == other.id and self.account == other.account
+
+    def __ne__(self, other) -> bool:
+        return not self == other
+
+    def __repr__(self) -> str:
+        return f"<Chat id={self.id} account={self.account.id}>"
+
+    async def delete(self) -> None:
         """Delete this chat and all its messages.
 
         Note:
@@ -33,147 +42,140 @@ class Chat:
         - does not delete messages on server
         - the chat or contact is not blocked, new message will arrive
         """
-        self._rpc.delete_chat(self.account.id, self.id)
+        await self._rpc.delete_chat(self.account.id, self.id)
 
-    def block(self) -> None:
+    async def block(self) -> None:
         """Block this chat."""
-        self._rpc.block_chat(self.account.id, self.id)
+        await self._rpc.block_chat(self.account.id, self.id)
 
-    def accept(self) -> None:
+    async def accept(self) -> None:
         """Accept this contact request chat."""
-        self._rpc.accept_chat(self.account.id, self.id)
+        await self._rpc.accept_chat(self.account.id, self.id)
 
-    def leave(self) -> None:
+    async def leave(self) -> None:
         """Leave this chat."""
-        self._rpc.leave_group(self.account.id, self.id)
+        await self._rpc.leave_group(self.account.id, self.id)
 
-    def mute(self, duration: Optional[int] = None) -> None:
+    async def mute(self, duration: Optional[int] = None) -> None:
         """Mute this chat, if a duration is not provided the chat is muted forever.
 
         :param duration: mute duration from now in seconds. Must be greater than zero.
         """
         if duration is not None:
             assert duration > 0, "Invalid duration"
-            dur: dict = {"kind": "Until", "duration": duration}
+            dur: Union[str, dict] = dict(Until=duration)
         else:
-            dur = {"kind": "Forever"}
-        self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
+            dur = "Forever"
+        await self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
 
-    def unmute(self) -> None:
+    async def unmute(self) -> None:
         """Unmute this chat."""
-        self._rpc.set_chat_mute_duration(self.account.id, self.id, {"kind": "NotMuted"})
+        await self._rpc.set_chat_mute_duration(self.account.id, self.id, "NotMuted")
 
-    def pin(self) -> None:
+    async def pin(self) -> None:
         """Pin this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.PINNED
+        )
 
-    def unpin(self) -> None:
+    async def unpin(self) -> None:
         """Unpin this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.NORMAL
+        )
 
-    def archive(self) -> None:
+    async def archive(self) -> None:
         """Archive this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.ARCHIVED
+        )
 
-    def unarchive(self) -> None:
+    async def unarchive(self) -> None:
         """Unarchive this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.NORMAL
+        )
 
-    def set_name(self, name: str) -> None:
+    async def set_name(self, name: str) -> None:
         """Set name of this chat."""
-        self._rpc.set_chat_name(self.account.id, self.id, name)
+        await self._rpc.set_chat_name(self.account.id, self.id, name)
 
-    def set_ephemeral_timer(self, timer: int) -> None:
+    async def set_ephemeral_timer(self, timer: int) -> None:
         """Set ephemeral timer of this chat."""
-        self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
+        await self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
 
-    def get_encryption_info(self) -> str:
+    async def get_encryption_info(self) -> str:
         """Return encryption info for this chat."""
-        return self._rpc.get_chat_encryption_info(self.account.id, self.id)
+        return await self._rpc.get_chat_encryption_info(self.account.id, self.id)
 
-    def get_qr_code(self) -> Tuple[str, str]:
+    async def get_qr_code(self) -> Tuple[str, str]:
         """Get Join-Group QR code text and SVG data."""
-        return self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
+        return await self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
 
-    def get_basic_snapshot(self) -> AttrDict:
+    async def get_basic_snapshot(self) -> AttrDict:
         """Get a chat snapshot with basic info about this chat."""
-        info = self._rpc.get_basic_chat_info(self.account.id, self.id)
+        info = await self._rpc.get_basic_chat_info(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    def get_full_snapshot(self) -> AttrDict:
+    async def get_full_snapshot(self) -> AttrDict:
         """Get a full snapshot of this chat."""
-        info = self._rpc.get_full_chat_by_id(self.account.id, self.id)
+        info = await self._rpc.get_full_chat_by_id(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    def can_send(self) -> bool:
-        """Return true if messages can be sent to the chat."""
-        return self._rpc.can_send(self.account.id, self.id)
-
-    def send_message(
+    async def send_message(
         self,
         text: Optional[str] = None,
-        html: Optional[str] = None,
-        viewtype: Optional[ViewType] = None,
         file: Optional[str] = None,
         location: Optional[Tuple[float, float]] = None,
-        override_sender_name: Optional[str] = None,
         quoted_msg: Optional[Union[int, Message]] = None,
     ) -> Message:
         """Send a message and return the resulting Message instance."""
         if isinstance(quoted_msg, Message):
             quoted_msg = quoted_msg.id
 
-        draft = {
-            "text": text,
-            "html": html,
-            "viewtype": viewtype,
-            "file": file,
-            "location": location,
-            "overrideSenderName": override_sender_name,
-            "quotedMessageId": quoted_msg,
-        }
-        msg_id = self._rpc.send_msg(self.account.id, self.id, draft)
+        msg_id, _ = await self._rpc.misc_send_msg(
+            self.account.id, self.id, text, file, location, quoted_msg
+        )
         return Message(self.account, msg_id)
 
-    def send_text(self, text: str) -> Message:
+    async def send_text(self, text: str) -> Message:
         """Send a text message and return the resulting Message instance."""
-        msg_id = self._rpc.misc_send_text_message(self.account.id, self.id, text)
+        msg_id = await self._rpc.misc_send_text_message(self.account.id, self.id, text)
         return Message(self.account, msg_id)
 
-    def send_videochat_invitation(self) -> Message:
+    async def send_videochat_invitation(self) -> Message:
         """Send a videochat invitation and return the resulting Message instance."""
-        msg_id = self._rpc.send_videochat_invitation(self.account.id, self.id)
+        msg_id = await self._rpc.send_videochat_invitation(self.account.id, self.id)
         return Message(self.account, msg_id)
 
-    def send_sticker(self, path: str) -> Message:
+    async def send_sticker(self, path: str) -> Message:
         """Send an sticker and return the resulting Message instance."""
-        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
+        msg_id = await self._rpc.send_sticker(self.account.id, self.id, path)
         return Message(self.account, msg_id)
 
-    def forward_messages(self, messages: List[Message]) -> None:
+    async def forward_messages(self, messages: List[Message]) -> None:
         """Forward a list of messages to this chat."""
         msg_ids = [msg.id for msg in messages]
-        self._rpc.forward_messages(self.account.id, msg_ids, self.id)
+        await self._rpc.forward_messages(self.account.id, msg_ids, self.id)
 
-    def set_draft(
+    async def set_draft(
         self,
         text: Optional[str] = None,
         file: Optional[str] = None,
         quoted_msg: Optional[int] = None,
-        viewtype: Optional[str] = None,
     ) -> None:
         """Set draft message."""
         if isinstance(quoted_msg, Message):
             quoted_msg = quoted_msg.id
-        self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg, viewtype)
+        await self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg)
 
-    def remove_draft(self) -> None:
+    async def remove_draft(self) -> None:
         """Remove draft message."""
-        self._rpc.remove_draft(self.account.id, self.id)
+        await self._rpc.remove_draft(self.account.id, self.id)
 
-    def get_draft(self) -> Optional[AttrDict]:
+    async def get_draft(self) -> Optional[AttrDict]:
         """Get draft message."""
-        snapshot = self._rpc.get_draft(self.account.id, self.id)
+        snapshot = await self._rpc.get_draft(self.account.id, self.id)
         if not snapshot:
             return None
         snapshot = AttrDict(snapshot)
@@ -182,78 +184,80 @@ class Chat:
         snapshot["message"] = Message(self.account, snapshot.id)
         return snapshot
 
-    def get_messages(self, info_only: bool = False, add_daymarker: bool = False) -> List[Message]:
+    async def get_messages(self, flags: int = 0) -> List[Message]:
         """get the list of messages in this chat."""
-        msgs = self._rpc.get_message_ids(self.account.id, self.id, info_only, add_daymarker)
+        msgs = await self._rpc.get_message_ids(self.account.id, self.id, flags)
         return [Message(self.account, msg_id) for msg_id in msgs]
 
-    def get_fresh_message_count(self) -> int:
+    async def get_fresh_message_count(self) -> int:
         """Get number of fresh messages in this chat"""
-        return self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
+        return await self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
 
-    def mark_noticed(self) -> None:
+    async def mark_noticed(self) -> None:
         """Mark all messages in this chat as noticed."""
-        self._rpc.marknoticed_chat(self.account.id, self.id)
+        await self._rpc.marknoticed_chat(self.account.id, self.id)
 
-    def add_contact(self, *contact: Union[int, str, Contact]) -> None:
+    async def add_contact(self, *contact: Union[int, str, Contact]) -> None:
         """Add contacts to this group."""
         for cnt in contact:
             if isinstance(cnt, str):
-                contact_id = self.account.create_contact(cnt).id
+                cnt = (await self.account.create_contact(cnt)).id
             elif not isinstance(cnt, int):
-                contact_id = cnt.id
-            else:
-                contact_id = cnt
-            self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)
+                cnt = cnt.id
+            await self._rpc.add_contact_to_chat(self.account.id, self.id, cnt)
 
-    def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
+    async def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
         """Remove members from this group."""
         for cnt in contact:
             if isinstance(cnt, str):
-                contact_id = self.account.create_contact(cnt).id
+                cnt = (await self.account.create_contact(cnt)).id
             elif not isinstance(cnt, int):
-                contact_id = cnt.id
-            else:
-                contact_id = cnt
-            self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)
+                cnt = cnt.id
+            await self._rpc.remove_contact_from_chat(self.account.id, self.id, cnt)
 
-    def get_contacts(self) -> List[Contact]:
+    async def get_contacts(self) -> List[Contact]:
         """Get the contacts belonging to this chat.
 
         For single/direct chats self-address is not included.
         """
-        contacts = self._rpc.get_chat_contacts(self.account.id, self.id)
+        contacts = await self._rpc.get_chat_contacts(self.account.id, self.id)
         return [Contact(self.account, contact_id) for contact_id in contacts]
 
-    def set_image(self, path: str) -> None:
+    async def set_image(self, path: str) -> None:
         """Set profile image of this chat.
 
         :param path: Full path of the image to use as the group image.
         """
-        self._rpc.set_chat_profile_image(self.account.id, self.id, path)
+        await self._rpc.set_chat_profile_image(self.account.id, self.id, path)
 
-    def remove_image(self) -> None:
+    async def remove_image(self) -> None:
         """Remove profile image of this chat."""
-        self._rpc.set_chat_profile_image(self.account.id, self.id, None)
+        await self._rpc.set_chat_profile_image(self.account.id, self.id, None)
 
-    def get_locations(
+    async def get_locations(
         self,
         contact: Optional[Contact] = None,
-        timestamp_from: Optional["datetime"] = None,
-        timestamp_to: Optional["datetime"] = None,
+        timestamp_from: Optional[datetime] = None,
+        timestamp_to: Optional[datetime] = None,
     ) -> List[AttrDict]:
         """Get list of location snapshots for the given contact in the given timespan."""
-        time_from = calendar.timegm(timestamp_from.utctimetuple()) if timestamp_from else 0
+        time_from = (
+            calendar.timegm(timestamp_from.utctimetuple()) if timestamp_from else 0
+        )
         time_to = calendar.timegm(timestamp_to.utctimetuple()) if timestamp_to else 0
         contact_id = contact.id if contact else 0
 
-        result = self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
+        result = await self._rpc.get_locations(
+            self.account.id, self.id, contact_id, time_from, time_to
+        )
         locations = []
         contacts: Dict[int, Contact] = {}
         for loc in result:
-            location = AttrDict(loc)
-            location["chat"] = self
-            location["contact"] = contacts.setdefault(location.contact_id, Contact(self.account, location.contact_id))
-            location["message"] = Message(self.account, location.msg_id)
-            locations.append(location)
+            loc = AttrDict(loc)
+            loc["chat"] = self
+            loc["contact"] = contacts.setdefault(
+                loc.contact_id, Contact(self.account, loc.contact_id)
+            )
+            loc["message"] = Message(self.account, loc.msg_id)
+            locations.append(loc)
         return locations

deltachat-rpc-client/src/deltachat_rpc_client/client.py

@@ -1,35 +1,12 @@
 """Event loop implementations offering high level event handling/hooking."""
 import logging
-from typing import (
-    TYPE_CHECKING,
-    Callable,
-    Dict,
-    Iterable,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import Callable, Dict, Iterable, Optional, Set, Tuple, Type, Union
 
-from ._utils import (
-    AttrDict,
-    parse_system_add_remove,
-    parse_system_image_changed,
-    parse_system_title_changed,
-)
-from .const import COMMAND_PREFIX, EventType, SpecialContactId, SystemMessageType
-from .events import (
-    EventFilter,
-    GroupImageChanged,
-    GroupNameChanged,
-    MemberListChanged,
-    NewMessage,
-    RawEvent,
-)
+from deltachat_rpc_client.account import Account
 
-if TYPE_CHECKING:
-    from deltachat_rpc_client.account import Account
+from .const import EventType
+from .events import EventFilter, NewInfoMessage, NewMessage, RawEvent
+from .utils import AttrDict
 
 
 class Client:
@@ -37,166 +14,87 @@ class Client:
 
     def __init__(
         self,
-        account: "Account",
+        account: Account,
         hooks: Optional[Iterable[Tuple[Callable, Union[type, EventFilter]]]] = None,
         logger: Optional[logging.Logger] = None,
     ) -> None:
         self.account = account
         self.logger = logger or logging
         self._hooks: Dict[type, Set[tuple]] = {}
-        self._should_process_messages = 0
         self.add_hooks(hooks or [])
 
-    def add_hooks(self, hooks: Iterable[Tuple[Callable, Union[type, EventFilter]]]) -> None:
+    def add_hooks(
+        self, hooks: Iterable[Tuple[Callable, Union[type, EventFilter]]]
+    ) -> None:
         for hook, event in hooks:
             self.add_hook(hook, event)
 
-    def add_hook(self, hook: Callable, event: Union[type, EventFilter] = RawEvent) -> None:
+    def add_hook(
+        self, hook: Callable, event: Union[type, EventFilter] = RawEvent
+    ) -> None:
         """Register hook for the given event filter."""
         if isinstance(event, type):
             event = event()
         assert isinstance(event, EventFilter)
-        self._should_process_messages += int(
-            isinstance(
-                event,
-                (NewMessage, MemberListChanged, GroupImageChanged, GroupNameChanged),
-            ),
-        )
         self._hooks.setdefault(type(event), set()).add((hook, event))
 
     def remove_hook(self, hook: Callable, event: Union[type, EventFilter]) -> None:
         """Unregister hook from the given event filter."""
         if isinstance(event, type):
             event = event()
-        self._should_process_messages -= int(
-            isinstance(
-                event,
-                (NewMessage, MemberListChanged, GroupImageChanged, GroupNameChanged),
-            ),
-        )
         self._hooks.get(type(event), set()).remove((hook, event))
 
-    def is_configured(self) -> bool:
-        return self.account.is_configured()
+    async def is_configured(self) -> bool:
+        return await self.account.is_configured()
 
-    def configure(self, email: str, password: str, **kwargs) -> None:
-        self.account.set_config("addr", email)
-        self.account.set_config("mail_pw", password)
+    async def configure(self, email: str, password: str, **kwargs) -> None:
+        await self.account.set_config("addr", email)
+        await self.account.set_config("mail_pw", password)
         for key, value in kwargs.items():
-            self.account.set_config(key, value)
-        self.account.configure()
+            await self.account.set_config(key, value)
+        await self.account.configure()
         self.logger.debug("Account configured")
 
-    def run_forever(self) -> None:
-        """Process events forever."""
-        self.run_until(lambda _: False)
-
-    def run_until(self, func: Callable[[AttrDict], bool]) -> AttrDict:
-        """Process events until the given callable evaluates to True.
-
-        The callable should accept an AttrDict object representing the
-        last processed event. The event is returned when the callable
-        evaluates to True.
-        """
+    async def run_forever(self) -> None:
         self.logger.debug("Listening to incoming events...")
-        if self.is_configured():
-            self.account.start_io()
-        self._process_messages()  # Process old messages.
+        if await self.is_configured():
+            await self.account.start_io()
+        await self._process_messages()  # Process old messages.
         while True:
-            event = self.account.wait_for_event()
-            event["kind"] = EventType(event.kind)
+            event = await self.account.wait_for_event()
+            event["type"] = EventType(event.type)
             event["account"] = self.account
-            self._on_event(event)
-            if event.kind == EventType.INCOMING_MSG:
-                self._process_messages()
+            await self._on_event(event)
+            if event.type == EventType.INCOMING_MSG:
+                await self._process_messages()
 
-            stop = func(event)
-            if stop:
-                return event
-
-    def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
+    async def _on_event(
+        self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent
+    ) -> None:
         for hook, evfilter in self._hooks.get(filter_type, []):
-            if evfilter.filter(event):
+            if await evfilter.filter(event):
                 try:
-                    hook(event)
+                    await hook(event)
                 except Exception as ex:
                     self.logger.exception(ex)
 
-    def _parse_command(self, event: AttrDict) -> None:
-        cmds = [hook[1].command for hook in self._hooks.get(NewMessage, []) if hook[1].command]
-        parts = event.message_snapshot.text.split(maxsplit=1)
-        payload = parts[1] if len(parts) > 1 else ""
-        cmd = parts.pop(0)
+    def _should_process_messages(self) -> bool:
+        return any(issubclass(filter_type, NewMessage) for filter_type in self._hooks)
 
-        if "@" in cmd:
-            suffix = "@" + self.account.self_contact.get_snapshot().address
-            if cmd.endswith(suffix):
-                cmd = cmd[: -len(suffix)]
-            else:
-                return
-
-        parts = cmd.split("_")
-        _payload = payload
-        while parts:
-            _cmd = "_".join(parts)
-            if _cmd in cmds:
-                break
-            _payload = (parts.pop() + " " + _payload).rstrip()
-
-        if parts:
-            cmd = _cmd
-            payload = _payload
-
-        event["command"], event["payload"] = cmd, payload
-
-    def _on_new_msg(self, snapshot: AttrDict) -> None:
-        event = AttrDict(command="", payload="", message_snapshot=snapshot)
-        if not snapshot.is_info and snapshot.text.startswith(COMMAND_PREFIX):
-            self._parse_command(event)
-        self._on_event(event, NewMessage)
-
-    def _handle_info_msg(self, snapshot: AttrDict) -> None:
-        event = AttrDict(message_snapshot=snapshot)
-
-        img_changed = parse_system_image_changed(snapshot.text)
-        if img_changed:
-            _, event["image_deleted"] = img_changed
-            self._on_event(event, GroupImageChanged)
-            return
-
-        title_changed = parse_system_title_changed(snapshot.text)
-        if title_changed:
-            _, event["old_name"] = title_changed
-            self._on_event(event, GroupNameChanged)
-            return
-
-        members_changed = parse_system_add_remove(snapshot.text)
-        if members_changed:
-            action, event["member"], _ = members_changed
-            event["member_added"] = action == "added"
-            self._on_event(event, MemberListChanged)
-            return
-
-        self.logger.warning(
-            "ignoring unsupported system message id=%s text=%s",
-            snapshot.id,
-            snapshot.text,
-        )
-
-    def _process_messages(self) -> None:
-        if self._should_process_messages:
-            for message in self.account.get_next_messages():
-                snapshot = message.get_snapshot()
-                if snapshot.from_id not in [SpecialContactId.SELF, SpecialContactId.DEVICE]:
-                    self._on_new_msg(snapshot)
-                if snapshot.is_info and snapshot.system_message_type != SystemMessageType.WEBXDC_INFO_MESSAGE:
-                    self._handle_info_msg(snapshot)
-                snapshot.message.mark_seen()
+    async def _process_messages(self) -> None:
+        if self._should_process_messages():
+            for message in await self.account.get_fresh_messages_in_arrival_order():
+                snapshot = await message.get_snapshot()
+                if snapshot.is_info:
+                    await self._on_event(snapshot, NewInfoMessage)
+                else:
+                    await self._on_event(snapshot, NewMessage)
+                await snapshot.message.mark_seen()
 
 
 class Bot(Client):
     """Simple bot implementation that listent to events of a single account."""
 
-    def configure(self, email: str, password: str, **kwargs) -> None:
+    async def configure(self, email: str, password: str, **kwargs) -> None:
         kwargs.setdefault("bot", "1")
-        super().configure(email, password, **kwargs)
+        await super().configure(email, password, **kwargs)

deltachat-rpc-client/src/deltachat_rpc_client/const.py

@@ -1,7 +1,5 @@
 from enum import Enum, IntEnum
 
-COMMAND_PREFIX = "/"
-
 
 class ContactFlag(IntEnum):
     VERIFIED_ONLY = 0x01
@@ -31,7 +29,6 @@ class EventType(str, Enum):
     SMTP_MESSAGE_SENT = "SmtpMessageSent"
     IMAP_MESSAGE_DELETED = "ImapMessageDeleted"
     IMAP_MESSAGE_MOVED = "ImapMessageMoved"
-    IMAP_INBOX_IDLE = "ImapInboxIdle"
     NEW_BLOB_FILE = "NewBlobFile"
     DELETED_BLOB_FILE = "DeletedBlobFile"
     WARNING = "Warning"
@@ -45,7 +42,6 @@ class EventType(str, Enum):
     MSG_DELIVERED = "MsgDelivered"
     MSG_FAILED = "MsgFailed"
     MSG_READ = "MsgRead"
-    MSG_DELETED = "MsgDeleted"
     CHAT_MODIFIED = "ChatModified"
     CHAT_EPHEMERAL_TIMER_MODIFIED = "ChatEphemeralTimerModified"
     CONTACTS_CHANGED = "ContactsChanged"

deltachat-rpc-client/src/deltachat_rpc_client/contact.py

@@ -1,15 +1,13 @@
-from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from ._utils import AttrDict
+from .rpc import Rpc
+from .utils import AttrDict
 
 if TYPE_CHECKING:
     from .account import Account
     from .chat import Chat
-    from .rpc import Rpc
 
 
-@dataclass
 class Contact:
     """
     Contact API.
@@ -17,46 +15,58 @@ class Contact:
     Essentially a wrapper for RPC, account ID and a contact ID.
     """
 
-    account: "Account"
-    id: int
+    def __init__(self, account: "Account", contact_id: int) -> None:
+        self.account = account
+        self.id = contact_id
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Contact):
+            return False
+        return self.id == other.id and self.account == other.account
+
+    def __ne__(self, other) -> bool:
+        return not self == other
+
+    def __repr__(self) -> str:
+        return f"<Contact id={self.id} account={self.account.id}>"
 
     @property
-    def _rpc(self) -> "Rpc":
+    def _rpc(self) -> Rpc:
         return self.account._rpc
 
-    def block(self) -> None:
+    async def block(self) -> None:
         """Block contact."""
-        self._rpc.block_contact(self.account.id, self.id)
+        await self._rpc.block_contact(self.account.id, self.id)
 
-    def unblock(self) -> None:
+    async def unblock(self) -> None:
         """Unblock contact."""
-        self._rpc.unblock_contact(self.account.id, self.id)
+        await self._rpc.unblock_contact(self.account.id, self.id)
 
-    def delete(self) -> None:
+    async def delete(self) -> None:
         """Delete contact."""
-        self._rpc.delete_contact(self.account.id, self.id)
+        await self._rpc.delete_contact(self.account.id, self.id)
 
-    def set_name(self, name: str) -> None:
+    async def set_name(self, name: str) -> None:
         """Change the name of this contact."""
-        self._rpc.change_contact_name(self.account.id, self.id, name)
+        await self._rpc.change_contact_name(self.account.id, self.id, name)
 
-    def get_encryption_info(self) -> str:
+    async def get_encryption_info(self) -> str:
         """Get a multi-line encryption info, containing your fingerprint and
         the fingerprint of the contact.
         """
-        return self._rpc.get_contact_encryption_info(self.account.id, self.id)
+        return await self._rpc.get_contact_encryption_info(self.account.id, self.id)
 
-    def get_snapshot(self) -> AttrDict:
+    async def get_snapshot(self) -> AttrDict:
         """Return a dictionary with a snapshot of all contact properties."""
-        snapshot = AttrDict(self._rpc.get_contact(self.account.id, self.id))
+        snapshot = AttrDict(await self._rpc.get_contact(self.account.id, self.id))
         snapshot["contact"] = self
         return snapshot
 
-    def create_chat(self) -> "Chat":
+    async def create_chat(self) -> "Chat":
         """Create or get an existing 1:1 chat for this contact."""
         from .chat import Chat
 
         return Chat(
             self.account,
-            self._rpc.create_chat_by_contact_id(self.account.id, self.id),
+            await self._rpc.create_chat_by_contact_id(self.account.id, self.id),
         )

deltachat-rpc-client/src/deltachat_rpc_client/deltachat.py

@@ -1,10 +1,8 @@
-from typing import TYPE_CHECKING, Dict, List
+from typing import Dict, List
 
-from ._utils import AttrDict
 from .account import Account
-
-if TYPE_CHECKING:
-    from .rpc import Rpc
+from .rpc import Rpc
+from .utils import AttrDict
 
 
 class DeltaChat:
@@ -13,37 +11,37 @@ class DeltaChat:
     This is the root of the object oriented API.
     """
 
-    def __init__(self, rpc: "Rpc") -> None:
+    def __init__(self, rpc: Rpc) -> None:
         self.rpc = rpc
 
-    def add_account(self) -> Account:
+    async def add_account(self) -> Account:
         """Create a new account database."""
-        account_id = self.rpc.add_account()
+        account_id = await self.rpc.add_account()
         return Account(self, account_id)
 
-    def get_all_accounts(self) -> List[Account]:
+    async def get_all_accounts(self) -> List[Account]:
         """Return a list of all available accounts."""
-        account_ids = self.rpc.get_all_account_ids()
+        account_ids = await self.rpc.get_all_account_ids()
         return [Account(self, account_id) for account_id in account_ids]
 
-    def start_io(self) -> None:
+    async def start_io(self) -> None:
         """Start the I/O of all accounts."""
-        self.rpc.start_io_for_all_accounts()
+        await self.rpc.start_io_for_all_accounts()
 
-    def stop_io(self) -> None:
+    async def stop_io(self) -> None:
         """Stop the I/O of all accounts."""
-        self.rpc.stop_io_for_all_accounts()
+        await self.rpc.stop_io_for_all_accounts()
 
-    def maybe_network(self) -> None:
+    async def maybe_network(self) -> None:
         """Indicate that the network likely has come back or just that the network
         conditions might have changed.
         """
-        self.rpc.maybe_network()
+        await self.rpc.maybe_network()
 
-    def get_system_info(self) -> AttrDict:
+    async def get_system_info(self) -> AttrDict:
         """Get information about the Delta Chat core in this system."""
-        return AttrDict(self.rpc.get_system_info())
+        return AttrDict(await self.rpc.get_system_info())
 
-    def set_translations(self, translations: Dict[str, str]) -> None:
+    async def set_translations(self, translations: Dict[str, str]) -> None:
         """Set stock translation strings."""
-        self.rpc.set_stock_strings(translations)
+        await self.rpc.set_stock_strings(translations)

deltachat-rpc-client/src/deltachat_rpc_client/events.py

@@ -1,17 +1,16 @@
 """High-level classes for event processing and filtering."""
+import inspect
 import re
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Set, Tuple, Union
+from typing import Callable, Iterable, Iterator, Optional, Set, Tuple, Union
 
 from .const import EventType
-
-if TYPE_CHECKING:
-    from ._utils import AttrDict
+from .utils import AttrDict
 
 
 def _tuple_of(obj, type_: type) -> tuple:
     if not obj:
-        return ()
+        return tuple()
     if isinstance(obj, type_):
         obj = (obj,)
 
@@ -23,7 +22,7 @@ def _tuple_of(obj, type_: type) -> tuple:
 class EventFilter(ABC):
     """The base event filter.
 
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -40,15 +39,18 @@ class EventFilter(ABC):
         """Return True if two event filters are equal."""
 
     def __ne__(self, other):
-        return not self == other
+        return not self.__eq__(other)
 
-    def _call_func(self, event) -> bool:
+    async def _call_func(self, event) -> bool:
         if not self.func:
             return True
-        return self.func(event)
+        res = self.func(event)
+        if inspect.isawaitable(res):
+            return await res
+        return res
 
     @abstractmethod
-    def filter(self, event):
+    async def filter(self, event):
         """Return True-like value if the event passed the filter and should be
         used, or False-like value otherwise.
         """
@@ -58,12 +60,14 @@ class RawEvent(EventFilter):
     """Matches raw core events.
 
     :param types: The types of event to match.
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
 
-    def __init__(self, types: Union[None, EventType, Iterable[EventType]] = None, **kwargs):
+    def __init__(
+        self, types: Union[None, EventType, Iterable[EventType]] = None, **kwargs
+    ):
         super().__init__(**kwargs)
         try:
             self.types = _tuple_of(types, EventType)
@@ -78,31 +82,17 @@ class RawEvent(EventFilter):
             return (self.types, self.func) == (other.types, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
-        if self.types and event.kind not in self.types:
+    async def filter(self, event: AttrDict) -> bool:
+        if self.types and event.type not in self.types:
             return False
-        return self._call_func(event)
+        return await self._call_func(event)
 
 
 class NewMessage(EventFilter):
     """Matches whenever a new message arrives.
 
-    Warning: registering a handler for this event will cause the messages
+    Warning: registering a handler for this event or any subclass will cause the messages
     to be marked as read. Its usage is mainly intended for bots.
-
-    :param pattern: if set, this Pattern will be used to filter the message by its text
-                    content.
-    :param command: If set, only match messages with the given command (ex. /help).
-                    Setting this property implies `is_info==False`.
-    :param is_bot: If set to True only match messages sent by bots, if set to None
-                   match messages from bots and users. If omitted or set to False
-                   only messages from users will be matched.
-    :param is_info: If set to True only match info/system messages, if set to False
-                    only match messages that are not info/system messages. If omitted
-                    info/system messages as well as normal messages will be matched.
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
     """
 
     def __init__(
@@ -113,19 +103,9 @@ class NewMessage(EventFilter):
             Callable[[str], bool],
             re.Pattern,
         ] = None,
-        command: Optional[str] = None,
-        is_bot: Optional[bool] = False,
-        is_info: Optional[bool] = None,
-        func: Optional[Callable[["AttrDict"], bool]] = None,
+        func: Optional[Callable[[AttrDict], bool]] = None,
     ) -> None:
         super().__init__(func=func)
-        self.is_bot = is_bot
-        self.is_info = is_info
-        if command is not None and not isinstance(command, str):
-            raise TypeError("Invalid command")
-        self.command = command
-        if self.is_info and self.command:
-            raise AttributeError("Can not use command and is_info at the same time.")
         if isinstance(pattern, str):
             pattern = re.compile(pattern)
         if isinstance(pattern, re.Pattern):
@@ -136,124 +116,25 @@ class NewMessage(EventFilter):
             raise TypeError("Invalid pattern type")
 
     def __hash__(self) -> int:
-        return hash((self.pattern, self.command, self.is_bot, self.is_info, self.func))
+        return hash((self.pattern, self.func))
 
     def __eq__(self, other) -> bool:
-        if isinstance(other, NewMessage):
-            return (
-                self.pattern,
-                self.command,
-                self.is_bot,
-                self.is_info,
-                self.func,
-            ) == (
-                other.pattern,
-                other.command,
-                other.is_bot,
-                other.is_info,
-                other.func,
-            )
+        if type(other) is self.__class__:  # noqa
+            return (self.pattern, self.func) == (other.pattern, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
-        if self.is_bot is not None and self.is_bot != event.message_snapshot.is_bot:
-            return False
-        if self.is_info is not None and self.is_info != event.message_snapshot.is_info:
-            return False
-        if self.command and self.command != event.command:
-            return False
+    async def filter(self, event: AttrDict) -> bool:
         if self.pattern:
-            match = self.pattern(event.message_snapshot.text)
+            match = self.pattern(event.text)
+            if inspect.isawaitable(match):
+                match = await match
             if not match:
                 return False
-        return super()._call_func(event)
+        return await super()._call_func(event)
 
 
-class MemberListChanged(EventFilter):
-    """Matches when a group member is added or removed.
-
-    Warning: registering a handler for this event will cause the messages
-    to be marked as read. Its usage is mainly intended for bots.
-
-    :param added: If set to True only match if a member was added, if set to False
-                  only match if a member was removed. If omitted both, member additions
-                  and removals, will be matched.
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
-    """
-
-    def __init__(self, added: Optional[bool] = None, **kwargs):
-        super().__init__(**kwargs)
-        self.added = added
-
-    def __hash__(self) -> int:
-        return hash((self.added, self.func))
-
-    def __eq__(self, other) -> bool:
-        if isinstance(other, MemberListChanged):
-            return (self.added, self.func) == (other.added, other.func)
-        return False
-
-    def filter(self, event: "AttrDict") -> bool:
-        if self.added is not None and self.added != event.member_added:
-            return False
-        return self._call_func(event)
-
-
-class GroupImageChanged(EventFilter):
-    """Matches when the group image is changed.
-
-    Warning: registering a handler for this event will cause the messages
-    to be marked as read. Its usage is mainly intended for bots.
-
-    :param deleted: If set to True only match if the image was deleted, if set to False
-                    only match if a new image was set. If omitted both, image changes and
-                    removals, will be matched.
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
-    """
-
-    def __init__(self, deleted: Optional[bool] = None, **kwargs):
-        super().__init__(**kwargs)
-        self.deleted = deleted
-
-    def __hash__(self) -> int:
-        return hash((self.deleted, self.func))
-
-    def __eq__(self, other) -> bool:
-        if isinstance(other, GroupImageChanged):
-            return (self.deleted, self.func) == (other.deleted, other.func)
-        return False
-
-    def filter(self, event: "AttrDict") -> bool:
-        if self.deleted is not None and self.deleted != event.image_deleted:
-            return False
-        return self._call_func(event)
-
-
-class GroupNameChanged(EventFilter):
-    """Matches when the group name is changed.
-
-    Warning: registering a handler for this event will cause the messages
-    to be marked as read. Its usage is mainly intended for bots.
-
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
-    """
-
-    def __hash__(self) -> int:
-        return hash((GroupNameChanged, self.func))
-
-    def __eq__(self, other) -> bool:
-        if isinstance(other, GroupNameChanged):
-            return self.func == other.func
-        return False
-
-    def filter(self, event: "AttrDict") -> bool:
-        return self._call_func(event)
+class NewInfoMessage(NewMessage):
+    """Matches whenever a new info/system message arrives."""
 
 
 class HookCollection:

deltachat-rpc-client/src/deltachat_rpc_client/message.py

@@ -1,63 +1,49 @@
-import json
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
-from ._utils import AttrDict
 from .contact import Contact
+from .rpc import Rpc
+from .utils import AttrDict
 
 if TYPE_CHECKING:
     from .account import Account
-    from .rpc import Rpc
 
 
-@dataclass
 class Message:
     """Delta Chat Message object."""
 
-    account: "Account"
-    id: int
+    def __init__(self, account: "Account", msg_id: int) -> None:
+        self.account = account
+        self.id = msg_id
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Message):
+            return False
+        return self.id == other.id and self.account == other.account
+
+    def __ne__(self, other) -> bool:
+        return not self == other
+
+    def __repr__(self) -> str:
+        return f"<Message id={self.id} account={self.account.id}>"
 
     @property
-    def _rpc(self) -> "Rpc":
+    def _rpc(self) -> Rpc:
         return self.account._rpc
 
-    def send_reaction(self, *reaction: str):
+    async def send_reaction(self, *reaction: str):
         """Send a reaction to this message."""
-        self._rpc.send_reaction(self.account.id, self.id, reaction)
+        await self._rpc.send_reaction(self.account.id, self.id, reaction)
 
-    def get_snapshot(self) -> AttrDict:
+    async def get_snapshot(self) -> AttrDict:
         """Get a snapshot with the properties of this message."""
         from .chat import Chat
 
-        snapshot = AttrDict(self._rpc.get_message(self.account.id, self.id))
+        snapshot = AttrDict(await self._rpc.get_message(self.account.id, self.id))
         snapshot["chat"] = Chat(self.account, snapshot.chat_id)
         snapshot["sender"] = Contact(self.account, snapshot.from_id)
         snapshot["message"] = self
         return snapshot
 
-    def get_reactions(self) -> Optional[AttrDict]:
-        """Get message reactions."""
-        reactions = self._rpc.get_message_reactions(self.account.id, self.id)
-        if reactions:
-            return AttrDict(reactions)
-        return None
-
-    def get_sender_contact(self) -> Contact:
-        from_id = self.get_snapshot().from_id
-        return self.account.get_contact_by_id(from_id)
-
-    def mark_seen(self) -> None:
+    async def mark_seen(self) -> None:
         """Mark the message as seen."""
-        self._rpc.markseen_msgs(self.account.id, [self.id])
-
-    def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
-        """Send a webxdc status update. This message must be a webxdc."""
-        if not isinstance(update, str):
-            update = json.dumps(update)
-        self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
-
-    def get_webxdc_status_updates(self, last_known_serial: int = 0) -> list:
-        return json.loads(self._rpc.get_webxdc_status_updates(self.account.id, self.id, last_known_serial))
-
-    def get_webxdc_info(self) -> dict:
-        return self._rpc.get_webxdc_info(self.account.id, self.id)
+        await self._rpc.markseen_msgs(self.account.id, [self.id])

deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py

@@ -1,120 +1,64 @@
+import json
 import os
-import random
-from typing import AsyncGenerator, List, Optional
+from typing import AsyncGenerator, List
 
-import pytest
+import aiohttp
+import pytest_asyncio
 
-from . import Account, AttrDict, Bot, Client, DeltaChat, EventType, Message
+from .account import Account
+from .client import Bot
+from .deltachat import DeltaChat
 from .rpc import Rpc
 
 
-def get_temp_credentials() -> dict:
-    domain = os.getenv("CHATMAIL_DOMAIN")
-    username = "ci-" + "".join(random.choice("2345789acdefghjkmnpqrstuvwxyz") for i in range(6))
-    password = f"{username}${username}"
-    addr = f"{username}@{domain}"
-    return {"email": addr, "password": password}
+async def get_temp_credentials() -> dict:
+    url = os.getenv("DCC_NEW_TMP_EMAIL")
+    assert url, "Failed to get online account, DCC_NEW_TMP_EMAIL is not set"
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url) as response:
+            return json.loads(await response.text())
 
 
 class ACFactory:
     def __init__(self, deltachat: DeltaChat) -> None:
         self.deltachat = deltachat
 
-    def get_unconfigured_account(self) -> Account:
-        account = self.deltachat.add_account()
-        account.set_config("verified_one_on_one_chats", "1")
+    async def get_unconfigured_account(self) -> Account:
+        return await self.deltachat.add_account()
+
+    async def get_unconfigured_bot(self) -> Bot:
+        return Bot(await self.get_unconfigured_account())
+
+    async def new_configured_account(self) -> Account:
+        credentials = await get_temp_credentials()
+        account = await self.get_unconfigured_account()
+        assert not await account.is_configured()
+        await account.set_config("addr", credentials["email"])
+        await account.set_config("mail_pw", credentials["password"])
+        await account.configure()
+        assert await account.is_configured()
         return account
 
-    def get_unconfigured_bot(self) -> Bot:
-        return Bot(self.get_unconfigured_account())
-
-    def new_preconfigured_account(self) -> Account:
-        """Make a new account with configuration options set, but configuration not started."""
-        credentials = get_temp_credentials()
-        account = self.get_unconfigured_account()
-        account.set_config("addr", credentials["email"])
-        account.set_config("mail_pw", credentials["password"])
-        assert not account.is_configured()
-        return account
-
-    def new_configured_account(self) -> Account:
-        account = self.new_preconfigured_account()
-        account.configure()
-        assert account.is_configured()
-        return account
-
-    def new_configured_bot(self) -> Bot:
-        credentials = get_temp_credentials()
-        bot = self.get_unconfigured_bot()
-        bot.configure(credentials["email"], credentials["password"])
+    async def new_configured_bot(self) -> Bot:
+        credentials = await get_temp_credentials()
+        bot = await self.get_unconfigured_bot()
+        await bot.configure(credentials["email"], credentials["password"])
         return bot
 
-    def get_online_account(self) -> Account:
-        account = self.new_configured_account()
-        account.start_io()
-        while True:
-            event = account.wait_for_event()
-            if event.kind == EventType.IMAP_INBOX_IDLE:
-                break
-        return account
-
-    def get_online_accounts(self, num: int) -> List[Account]:
-        return [self.get_online_account() for _ in range(num)]
-
-    def resetup_account(self, ac: Account) -> Account:
-        """Resetup account from scratch, losing the encryption key."""
-        ac.stop_io()
-        ac_clone = self.get_unconfigured_account()
-        for i in ["addr", "mail_pw"]:
-            ac_clone.set_config(i, ac.get_config(i))
-        ac.remove()
-        ac_clone.configure()
-        return ac_clone
-
-    def send_message(
-        self,
-        to_account: Account,
-        from_account: Optional[Account] = None,
-        text: Optional[str] = None,
-        file: Optional[str] = None,
-        group: Optional[str] = None,
-    ) -> Message:
-        if not from_account:
-            from_account = (self.get_online_accounts(1))[0]
-        to_contact = from_account.create_contact(to_account.get_config("addr"))
-        if group:
-            to_chat = from_account.create_group(group)
-            to_chat.add_contact(to_contact)
-        else:
-            to_chat = to_contact.create_chat()
-        return to_chat.send_message(text=text, file=file)
-
-    def process_message(
-        self,
-        to_client: Client,
-        from_account: Optional[Account] = None,
-        text: Optional[str] = None,
-        file: Optional[str] = None,
-        group: Optional[str] = None,
-    ) -> AttrDict:
-        self.send_message(
-            to_account=to_client.account,
-            from_account=from_account,
-            text=text,
-            file=file,
-            group=group,
-        )
-
-        return to_client.run_until(lambda e: e.kind == EventType.INCOMING_MSG)
+    async def get_online_accounts(self, num: int) -> List[Account]:
+        accounts = [await self.new_configured_account() for _ in range(num)]
+        for account in accounts:
+            await account.start_io()
+        return accounts
 
 
-@pytest.fixture()
-def rpc(tmp_path) -> AsyncGenerator:
+@pytest_asyncio.fixture
+async def rpc(tmp_path) -> AsyncGenerator:
     rpc_server = Rpc(accounts_dir=str(tmp_path / "accounts"))
-    with rpc_server:
+    async with rpc_server:
         yield rpc_server
 
 
-@pytest.fixture()
-def acfactory(rpc) -> AsyncGenerator:
-    return ACFactory(DeltaChat(rpc))
+@pytest_asyncio.fixture
+async def acfactory(rpc) -> AsyncGenerator:
+    yield ACFactory(DeltaChat(rpc))

deltachat-rpc-client/src/deltachat_rpc_client/rpc.py

@@ -1,12 +1,7 @@
-import itertools
+import asyncio
 import json
-import logging
 import os
-import subprocess
-import sys
-from queue import Queue
-from threading import Event, Thread
-from typing import Any, Dict, Iterator, Optional
+from typing import Any, Dict, Optional
 
 
 class JsonRpcError(Exception):
@@ -15,154 +10,94 @@ class JsonRpcError(Exception):
 
 class Rpc:
     def __init__(self, accounts_dir: Optional[str] = None, **kwargs):
-        """The given arguments will be passed to subprocess.Popen()"""
+        """The given arguments will be passed to asyncio.create_subprocess_exec()"""
         if accounts_dir:
             kwargs["env"] = {
                 **kwargs.get("env", os.environ),
-                "DC_ACCOUNTS_PATH": str(accounts_dir),
+                "DC_ACCOUNTS_PATH": os.path.abspath(
+                    os.path.expanduser(str(accounts_dir))
+                ),
             }
 
         self._kwargs = kwargs
-        self.process: subprocess.Popen
-        self.id_iterator: Iterator[int]
-        self.event_queues: Dict[int, Queue]
-        # Map from request ID to `threading.Event`.
-        self.request_events: Dict[int, Event]
-        # Map from request ID to the result.
-        self.request_results: Dict[int, Any]
-        self.request_queue: Queue[Any]
-        self.closing: bool
-        self.reader_thread: Thread
-        self.writer_thread: Thread
-        self.events_thread: Thread
+        self.process: asyncio.subprocess.Process
+        self.id: int
+        self.event_queues: Dict[int, asyncio.Queue]
+        # Map from request ID to `asyncio.Future` returning the response.
+        self.request_events: Dict[int, asyncio.Future]
+        self.reader_task: asyncio.Task
 
-    def start(self) -> None:
-        if sys.version_info >= (3, 11):
-            self.process = subprocess.Popen(
-                "deltachat-rpc-server",
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                # Prevent subprocess from capturing SIGINT.
-                process_group=0,
-                **self._kwargs,
-            )
-        else:
-            self.process = subprocess.Popen(
-                "deltachat-rpc-server",
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                # `process_group` is not supported before Python 3.11.
-                preexec_fn=os.setpgrp,  # noqa: PLW1509
-                **self._kwargs,
-            )
-        self.id_iterator = itertools.count(start=1)
+    async def start(self) -> None:
+        self.process = await asyncio.create_subprocess_exec(
+            "deltachat-rpc-server",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            **self._kwargs
+        )
+        self.id = 0
         self.event_queues = {}
         self.request_events = {}
-        self.request_results = {}
-        self.request_queue = Queue()
-        self.closing = False
-        self.reader_thread = Thread(target=self.reader_loop)
-        self.reader_thread.start()
-        self.writer_thread = Thread(target=self.writer_loop)
-        self.writer_thread.start()
-        self.events_thread = Thread(target=self.events_loop)
-        self.events_thread.start()
+        self.reader_task = asyncio.create_task(self.reader_loop())
 
-    def close(self) -> None:
+    async def close(self) -> None:
         """Terminate RPC server process and wait until the reader loop finishes."""
-        self.closing = True
-        self.stop_io_for_all_accounts()
-        self.events_thread.join()
-        self.process.stdin.close()
-        self.reader_thread.join()
-        self.request_queue.put(None)
-        self.writer_thread.join()
+        self.process.terminate()
+        await self.reader_task
 
-    def __enter__(self):
-        self.start()
+    async def __aenter__(self):
+        await self.start()
         return self
 
-    def __exit__(self, _exc_type, _exc, _tb):
-        self.close()
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
 
-    def reader_loop(self) -> None:
-        try:
-            while True:
-                line = self.process.stdout.readline()
-                if not line:  # EOF
-                    break
-                response = json.loads(line)
-                if "id" in response:
-                    response_id = response["id"]
-                    event = self.request_events.pop(response_id)
-                    self.request_results[response_id] = response
-                    event.set()
-                else:
-                    logging.warning("Got a response without ID: %s", response)
-        except Exception:
-            # Log an exception if the reader loop dies.
-            logging.exception("Exception in the reader loop")
+    async def reader_loop(self) -> None:
+        while True:
+            line = await self.process.stdout.readline()  # noqa
+            if not line:  # EOF
+                break
+            response = json.loads(line)
+            if "id" in response:
+                fut = self.request_events.pop(response["id"])
+                fut.set_result(response)
+            elif response["method"] == "event":
+                # An event notification.
+                params = response["params"]
+                account_id = params["contextId"]
+                if account_id not in self.event_queues:
+                    self.event_queues[account_id] = asyncio.Queue()
+                await self.event_queues[account_id].put(params["event"])
+            else:
+                print(response)
 
-    def writer_loop(self) -> None:
-        """Writer loop ensuring only a single thread writes requests."""
-        try:
-            while True:
-                request = self.request_queue.get()
-                if not request:
-                    break
-                data = (json.dumps(request) + "\n").encode()
-                self.process.stdin.write(data)
-                self.process.stdin.flush()
-
-        except Exception:
-            # Log an exception if the writer loop dies.
-            logging.exception("Exception in the writer loop")
-
-    def get_queue(self, account_id: int) -> Queue:
-        if account_id not in self.event_queues:
-            self.event_queues[account_id] = Queue()
-        return self.event_queues[account_id]
-
-    def events_loop(self) -> None:
-        """Requests new events and distributes them between queues."""
-        try:
-            while True:
-                if self.closing:
-                    return
-                event = self.get_next_event()
-                account_id = event["contextId"]
-                queue = self.get_queue(account_id)
-                event = event["event"]
-                logging.debug("account_id=%d got an event %s", account_id, event)
-                queue.put(event)
-        except Exception:
-            # Log an exception if the event loop dies.
-            logging.exception("Exception in the event loop")
-
-    def wait_for_event(self, account_id: int) -> Optional[dict]:
+    async def wait_for_event(self, account_id: int) -> Optional[dict]:
         """Waits for the next event from the given account and returns it."""
-        queue = self.get_queue(account_id)
-        return queue.get()
+        if account_id in self.event_queues:
+            return await self.event_queues[account_id].get()
+        return None
 
     def __getattr__(self, attr: str):
-        def method(*args) -> Any:
-            request_id = next(self.id_iterator)
+        async def method(*args, **kwargs) -> Any:
+            self.id += 1
+            request_id = self.id
+
+            assert not (args and kwargs), "Mixing positional and keyword arguments"
+
             request = {
                 "jsonrpc": "2.0",
                 "method": attr,
-                "params": args,
-                "id": request_id,
+                "params": kwargs or args,
+                "id": self.id,
             }
-            event = Event()
-            self.request_events[request_id] = event
-            self.request_queue.put(request)
-            event.wait()
-
-            response = self.request_results.pop(request_id)
+            data = (json.dumps(request) + "\n").encode()
+            self.process.stdin.write(data)  # noqa
+            loop = asyncio.get_running_loop()
+            fut = loop.create_future()
+            self.request_events[request_id] = fut
+            response = await fut
             if "error" in response:
                 raise JsonRpcError(response["error"])
             if "result" in response:
                 return response["result"]
-            return None
 
         return method

deltachat-rpc-client/src/deltachat_rpc_client/utils.py

@@ -0,0 +1,114 @@
+import argparse
+import asyncio
+import re
+import sys
+from typing import TYPE_CHECKING, Callable, Iterable, Optional, Tuple, Type, Union
+
+if TYPE_CHECKING:
+    from .client import Client
+    from .events import EventFilter
+
+
+def _camel_to_snake(name: str) -> str:
+    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    name = re.sub("__([A-Z])", r"_\1", name)
+    name = re.sub("([a-z0-9])([A-Z])", r"\1_\2", name)
+    return name.lower()
+
+
+def _to_attrdict(obj):
+    if isinstance(obj, dict):
+        return AttrDict(obj)
+    if isinstance(obj, list):
+        return [_to_attrdict(elem) for elem in obj]
+    return obj
+
+
+class AttrDict(dict):
+    """Dictionary that allows accessing values usin the "dot notation" as attributes."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(
+            {
+                _camel_to_snake(key): _to_attrdict(value)
+                for key, value in dict(*args, **kwargs).items()
+            }
+        )
+
+    def __getattr__(self, attr):
+        if attr in self:
+            return self[attr]
+        raise AttributeError("Attribute not found: " + str(attr))
+
+    def __setattr__(self, attr, val):
+        if attr in self:
+            raise AttributeError("Attribute-style access is read only")
+        super().__setattr__(attr, val)
+
+
+async def run_client_cli(
+    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
+    argv: Optional[list] = None,
+    **kwargs
+) -> None:
+    """Run a simple command line app, using the given hooks.
+
+    Extra keyword arguments are passed to the internal Rpc object.
+    """
+    from .client import Client
+
+    await _run_cli(Client, hooks, argv, **kwargs)
+
+
+async def run_bot_cli(
+    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
+    argv: Optional[list] = None,
+    **kwargs
+) -> None:
+    """Run a simple bot command line using the given hooks.
+
+    Extra keyword arguments are passed to the internal Rpc object.
+    """
+    from .client import Bot
+
+    await _run_cli(Bot, hooks, argv, **kwargs)
+
+
+async def _run_cli(
+    client_type: Type["Client"],
+    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
+    argv: Optional[list] = None,
+    **kwargs
+) -> None:
+    from .deltachat import DeltaChat
+    from .rpc import Rpc
+
+    if argv is None:
+        argv = sys.argv
+
+    parser = argparse.ArgumentParser(prog=argv[0] if argv else None)
+    parser.add_argument(
+        "accounts_dir",
+        help="accounts folder (default: current working directory)",
+        nargs="?",
+    )
+    parser.add_argument("--email", action="store", help="email address")
+    parser.add_argument("--password", action="store", help="password")
+    args = parser.parse_args(argv[1:])
+
+    async with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
+        deltachat = DeltaChat(rpc)
+        core_version = (await deltachat.get_system_info()).deltachat_core_version
+        accounts = await deltachat.get_all_accounts()
+        account = accounts[0] if accounts else await deltachat.add_account()
+
+        client = client_type(account, hooks)
+        client.logger.debug("Running deltachat core %s", core_version)
+        if not await client.is_configured():
+            assert (
+                args.email and args.password
+            ), "Account is not configured and email and password must be provided"
+            asyncio.create_task(
+                client.configure(email=args.email, password=args.password)
+            )
+        await client.run_forever()

deltachat-rpc-client/tests/test_securejoin.py

@@ -1,431 +0,0 @@
-import logging
-
-from deltachat_rpc_client import Chat, SpecialContactId
-
-
-def test_qr_setup_contact(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    qr_code, _svg = alice.get_qr_code()
-    bob.secure_join(qr_code)
-
-    alice.wait_for_securejoin_inviter_success()
-
-    # Test that Alice verified Bob's profile.
-    alice_contact_bob = alice.get_contact_by_addr(bob.get_config("addr"))
-    alice_contact_bob_snapshot = alice_contact_bob.get_snapshot()
-    assert alice_contact_bob_snapshot.is_verified
-
-    bob.wait_for_securejoin_joiner_success()
-
-    # Test that Bob verified Alice's profile.
-    bob_contact_alice = bob.get_contact_by_addr(alice.get_config("addr"))
-    bob_contact_alice_snapshot = bob_contact_alice.get_snapshot()
-    assert bob_contact_alice_snapshot.is_verified
-
-
-def test_qr_securejoin(acfactory):
-    alice, bob = acfactory.get_online_accounts(2)
-
-    logging.info("Alice creates a verified group")
-    alice_chat = alice.create_group("Verified group", protect=True)
-    assert alice_chat.get_basic_snapshot().is_protected
-
-    logging.info("Bob joins verified group")
-    qr_code, _svg = alice_chat.get_qr_code()
-    bob.secure_join(qr_code)
-
-    # Check that at least some of the handshake messages are deleted.
-    for ac in [alice, bob]:
-        while True:
-            event = ac.wait_for_event()
-            if event["kind"] == "ImapMessageDeleted":
-                break
-
-    alice.wait_for_securejoin_inviter_success()
-
-    # Test that Alice verified Bob's profile.
-    alice_contact_bob = alice.get_contact_by_addr(bob.get_config("addr"))
-    alice_contact_bob_snapshot = alice_contact_bob.get_snapshot()
-    assert alice_contact_bob_snapshot.is_verified
-
-    bob.wait_for_securejoin_joiner_success()
-
-    snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert snapshot.text == "Member Me ({}) added by {}.".format(bob.get_config("addr"), alice.get_config("addr"))
-    assert snapshot.chat.get_basic_snapshot().is_protected
-
-    # Test that Bob verified Alice's profile.
-    bob_contact_alice = bob.get_contact_by_addr(alice.get_config("addr"))
-    bob_contact_alice_snapshot = bob_contact_alice.get_snapshot()
-    assert bob_contact_alice_snapshot.is_verified
-
-
-def test_qr_securejoin_contact_request(acfactory) -> None:
-    """Alice invites Bob to a group when Bob's chat with Alice is in a contact request mode."""
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_text("Hello!")
-
-    snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert snapshot.text == "Hello!"
-    bob_chat_alice = snapshot.chat
-    assert bob_chat_alice.get_basic_snapshot().is_contact_request
-
-    alice_chat = alice.create_group("Verified group", protect=True)
-    logging.info("Bob joins verified group")
-    qr_code, _svg = alice_chat.get_qr_code()
-    bob.secure_join(qr_code)
-    while True:
-        event = bob.wait_for_event()
-        if event["kind"] == "SecurejoinJoinerProgress" and event["progress"] == 1000:
-            break
-
-    # Chat stays being a contact request.
-    assert bob_chat_alice.get_basic_snapshot().is_contact_request
-
-
-def test_qr_readreceipt(acfactory) -> None:
-    alice, bob, charlie = acfactory.get_online_accounts(3)
-
-    logging.info("Bob and Charlie setup contact with Alice")
-    qr_code, _svg = alice.get_qr_code()
-
-    bob.secure_join(qr_code)
-    charlie.secure_join(qr_code)
-
-    for joiner in [bob, charlie]:
-        joiner.wait_for_securejoin_joiner_success()
-
-    logging.info("Alice creates a verified group")
-    group = alice.create_group("Group", protect=True)
-
-    bob_addr = bob.get_config("addr")
-    charlie_addr = charlie.get_config("addr")
-
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_contact_charlie = alice.create_contact(charlie_addr, "Charlie")
-
-    group.add_contact(alice_contact_bob)
-    group.add_contact(alice_contact_charlie)
-
-    # Promote a group.
-    group.send_message(text="Hello")
-
-    logging.info("Bob and Charlie receive a group")
-
-    bob_msg_id = bob.wait_for_incoming_msg_event().msg_id
-    bob_message = bob.get_message_by_id(bob_msg_id)
-    bob_snapshot = bob_message.get_snapshot()
-    assert bob_snapshot.text == "Hello"
-
-    # Charlie receives the same "Hello" message as Bob.
-    charlie.wait_for_incoming_msg_event()
-
-    logging.info("Bob sends a message to the group")
-
-    bob_out_message = bob_snapshot.chat.send_message(text="Hi from Bob!")
-
-    charlie_msg_id = charlie.wait_for_incoming_msg_event().msg_id
-    charlie_message = charlie.get_message_by_id(charlie_msg_id)
-    charlie_snapshot = charlie_message.get_snapshot()
-    assert charlie_snapshot.text == "Hi from Bob!"
-
-    bob_contact_charlie = bob.create_contact(charlie_addr, "Charlie")
-    assert not bob.get_chat_by_contact(bob_contact_charlie)
-
-    logging.info("Charlie reads Bob's message")
-    charlie_message.mark_seen()
-
-    while True:
-        event = bob.wait_for_event()
-        if event["kind"] == "MsgRead" and event["msg_id"] == bob_out_message.id:
-            break
-
-    # Receiving a read receipt from Charlie
-    # should not unblock hidden chat with Charlie for Bob.
-    assert not bob.get_chat_by_contact(bob_contact_charlie)
-
-
-def test_verified_group_recovery(acfactory) -> None:
-    """Tests verified group recovery by reverifying a member and sending a message in a group."""
-    ac1, ac2, ac3 = acfactory.get_online_accounts(3)
-
-    logging.info("ac1 creates verified group")
-    chat = ac1.create_group("Verified group", protect=True)
-    assert chat.get_basic_snapshot().is_protected
-
-    logging.info("ac2 joins verified group")
-    qr_code, _svg = chat.get_qr_code()
-    ac2.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
-
-    # ac1 has ac2 directly verified.
-    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
-    assert ac1_contact_ac2.get_snapshot().verifier_id == SpecialContactId.SELF
-
-    logging.info("ac3 joins verified group")
-    ac3_chat = ac3.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
-
-    logging.info("ac2 logs in on a new device")
-    ac2 = acfactory.resetup_account(ac2)
-
-    logging.info("ac2 reverifies with ac3")
-    qr_code, _svg = ac3.get_qr_code()
-    ac2.secure_join(qr_code)
-
-    ac3.wait_for_securejoin_inviter_success()
-
-    logging.info("ac3 sends a message to the group")
-    assert len(ac3_chat.get_contacts()) == 3
-    ac3_chat.send_text("Hi!")
-
-    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert snapshot.text == "Hi!"
-
-    msg_id = ac2.wait_for_incoming_msg_event().msg_id
-    message = ac2.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
-    assert snapshot.text == "Hi!"
-
-    # ac1 contact is verified for ac2 because ac3 gossiped ac1 key in the "Hi!" message.
-    ac1_contact = ac2.get_contact_by_addr(ac1.get_config("addr"))
-    assert ac1_contact.get_snapshot().is_verified
-
-    # ac2 can write messages to the group.
-    snapshot.chat.send_text("Works again!")
-
-    snapshot = ac3.get_message_by_id(ac3.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert snapshot.text == "Works again!"
-
-    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert snapshot.text == "Works again!"
-
-    ac1_chat_messages = snapshot.chat.get_messages()
-    ac2_addr = ac2.get_config("addr")
-    assert ac1_chat_messages[-2].get_snapshot().text == f"Changed setup for {ac2_addr}"
-
-    # ac2 is now verified by ac3 for ac1
-    ac1_contact_ac3 = ac1.get_contact_by_addr(ac3.get_config("addr"))
-    assert ac1_contact_ac2.get_snapshot().verifier_id == ac1_contact_ac3.id
-
-
-def test_verified_group_member_added_recovery(acfactory) -> None:
-    """Tests verified group recovery by reverifiying than removing and adding a member back."""
-    ac1, ac2, ac3 = acfactory.get_online_accounts(3)
-
-    logging.info("ac1 creates verified group")
-    chat = ac1.create_group("Verified group", protect=True)
-    assert chat.get_basic_snapshot().is_protected
-
-    logging.info("ac2 joins verified group")
-    qr_code, _svg = chat.get_qr_code()
-    ac2.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
-
-    # ac1 has ac2 directly verified.
-    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
-    assert ac1_contact_ac2.get_snapshot().verifier_id == SpecialContactId.SELF
-
-    logging.info("ac3 joins verified group")
-    ac3_chat = ac3.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
-
-    logging.info("ac2 logs in on a new device")
-    ac2 = acfactory.resetup_account(ac2)
-
-    logging.info("ac2 reverifies with ac3")
-    qr_code, _svg = ac3.get_qr_code()
-    ac2.secure_join(qr_code)
-
-    ac3.wait_for_securejoin_inviter_success()
-
-    logging.info("ac3 sends a message to the group")
-    assert len(ac3_chat.get_contacts()) == 3
-    ac3_chat.send_text("Hi!")
-
-    msg_id = ac2.wait_for_incoming_msg_event().msg_id
-    message = ac2.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
-    logging.info("Received message %s", snapshot.text)
-    assert snapshot.text == "Hi!"
-
-    ac1.wait_for_incoming_msg_event()  # Hi!
-
-    ac3_contact_ac2 = ac3.get_contact_by_addr(ac2.get_config("addr"))
-    ac3_chat.remove_contact(ac3_contact_ac2)
-    ac3_chat.add_contact(ac3_contact_ac2)
-
-    msg_id = ac2.wait_for_incoming_msg_event().msg_id
-    message = ac2.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
-    assert "removed" in snapshot.text
-
-    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert "removed" in snapshot.text
-
-    event = ac2.wait_for_incoming_msg_event()
-    msg_id = event.msg_id
-    chat_id = event.chat_id
-    message = ac2.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
-    logging.info("ac2 got event message: %s", snapshot.text)
-    assert "added" in snapshot.text
-
-    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert "added" in snapshot.text
-
-    chat = Chat(ac2, chat_id)
-    chat.send_text("Works again!")
-
-    msg_id = ac3.wait_for_incoming_msg_event().msg_id
-    message = ac3.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
-    assert snapshot.text == "Works again!"
-
-    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert snapshot.text == "Works again!"
-
-    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
-    ac1_contact_ac2_snapshot = ac1_contact_ac2.get_snapshot()
-    assert ac1_contact_ac2_snapshot.is_verified
-    assert ac1_contact_ac2_snapshot.verifier_id == ac1.get_contact_by_addr(ac3.get_config("addr")).id
-
-    # ac2 is now verified by ac3 for ac1
-    ac1_contact_ac3 = ac1.get_contact_by_addr(ac3.get_config("addr"))
-    assert ac1_contact_ac2.get_snapshot().verifier_id == ac1_contact_ac3.id
-
-
-def test_qr_join_chat_with_pending_bobstate_issue4894(acfactory):
-    """Regression test for
-    issue <https://github.com/deltachat/deltachat-core-rust/issues/4894>.
-    """
-    ac1, ac2, ac3, ac4 = acfactory.get_online_accounts(4)
-
-    logging.info("ac3: verify with ac2")
-    qr_code, _svg = ac2.get_qr_code()
-    ac3.secure_join(qr_code)
-    ac2.wait_for_securejoin_inviter_success()
-
-    # in order for ac2 to have pending bobstate with a verified group
-    # we first create a fully joined verified group, and then start
-    # joining a second time but interrupt it, to create pending bob state
-
-    logging.info("ac1: create verified group that ac2 fully joins")
-    ch1 = ac1.create_group("Group", protect=True)
-    qr_code, _svg = ch1.get_qr_code()
-    ac2.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
-
-    # ensure ac1 can write and ac2 receives messages in verified chat
-    ch1.send_text("ac1 says hello")
-    while 1:
-        snapshot = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
-        if snapshot.text == "ac1 says hello":
-            assert snapshot.chat.get_basic_snapshot().is_protected
-            break
-
-    logging.info("ac1: let ac2 join again but shutoff ac1 in the middle of securejoin")
-    qr_code, _svg = ch1.get_qr_code()
-    ac2.secure_join(qr_code)
-    ac1.remove()
-    logging.info("ac2 now has pending bobstate but ac1 is shutoff")
-
-    # we meanwhile expect ac3/ac2 verification started in the beginning to have completed
-    assert ac3.get_contact_by_addr(ac2.get_config("addr")).get_snapshot().is_verified
-    assert ac2.get_contact_by_addr(ac3.get_config("addr")).get_snapshot().is_verified
-
-    logging.info("ac3: create a verified group VG with ac2")
-    vg = ac3.create_group("ac3-created", protect=True)
-    vg.add_contact(ac3.get_contact_by_addr(ac2.get_config("addr")))
-
-    # ensure ac2 receives message in VG
-    vg.send_text("hello")
-    while 1:
-        msg = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
-        if msg.text == "hello":
-            assert msg.chat.get_basic_snapshot().is_protected
-            break
-
-    logging.info("ac3: create a join-code for group VG and let ac4 join, check that ac2 got it")
-    qr_code, _svg = vg.get_qr_code()
-    ac4.secure_join(qr_code)
-    ac3.wait_for_securejoin_inviter_success()
-    while 1:
-        ev = ac2.wait_for_event()
-        if "added by unrelated SecureJoin" in str(ev):
-            return
-
-
-def test_qr_new_group_unblocked(acfactory):
-    """Regression test for a bug introduced in core v1.113.0.
-    ac2 scans a verified group QR code created by ac1.
-    This results in creation of a blocked 1:1 chat with ac1 on ac2,
-    but ac1 contact is not blocked on ac2.
-    Then ac1 creates a group, adds ac2 there and promotes it by sending a message.
-    ac2 should receive a message and create a contact request for the group.
-    Due to a bug previously ac2 created a blocked group.
-    """
-
-    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac1_chat = ac1.create_group("Group for joining", protect=True)
-    qr_code, _svg = ac1_chat.get_qr_code()
-    ac2.secure_join(qr_code)
-
-    ac1.wait_for_securejoin_inviter_success()
-
-    ac1_new_chat = ac1.create_group("Another group")
-    ac1_new_chat.add_contact(ac1.get_contact_by_addr(ac2.get_config("addr")))
-    # Receive "Member added" message.
-    ac2.wait_for_incoming_msg_event()
-
-    ac1_new_chat.send_text("Hello!")
-    ac2_msg = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert ac2_msg.text == "Hello!"
-    assert ac2_msg.chat.get_basic_snapshot().is_contact_request
-
-
-def test_aeap_flow_verified(acfactory):
-    """Test that a new address is added to a contact when it changes its address."""
-    ac1, ac2, ac1new = acfactory.get_online_accounts(3)
-
-    logging.info("ac1: create verified-group QR, ac2 scans and joins")
-    chat = ac1.create_group("hello", protect=True)
-    assert chat.get_basic_snapshot().is_protected
-    qr_code, _svg = chat.get_qr_code()
-    logging.info("ac2: start QR-code based join-group protocol")
-    ac2.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
-
-    logging.info("sending first message")
-    msg_out = chat.send_text("old address").get_snapshot()
-
-    logging.info("receiving first message")
-    ac2.wait_for_incoming_msg_event()  # member added message
-    msg_in_1 = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert msg_in_1.text == msg_out.text
-
-    logging.info("changing email account")
-    ac1.set_config("addr", ac1new.get_config("addr"))
-    ac1.set_config("mail_pw", ac1new.get_config("mail_pw"))
-    ac1.stop_io()
-    ac1.configure()
-    ac1.start_io()
-
-    logging.info("sending second message")
-    msg_out = chat.send_text("changed address").get_snapshot()
-
-    logging.info("receiving second message")
-    msg_in_2 = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id)
-    msg_in_2_snapshot = msg_in_2.get_snapshot()
-    assert msg_in_2_snapshot.text == msg_out.text
-    assert msg_in_2_snapshot.chat.id == msg_in_1.chat.id
-    assert msg_in_2.get_sender_contact().get_snapshot().address == ac1new.get_config("addr")
-    assert len(msg_in_2_snapshot.chat.get_contacts()) == 2
-    assert ac1new.get_config("addr") in [
-        contact.get_snapshot().address for contact in msg_in_2_snapshot.chat.get_contacts()
-    ]

deltachat-rpc-client/tests/test_something.py

@@ -1,33 +1,18 @@
-import concurrent.futures
-import json
-import subprocess
-from unittest.mock import MagicMock
-
 import pytest
-from deltachat_rpc_client import EventType, events
+
+from deltachat_rpc_client import AttrDict, EventType, events
 from deltachat_rpc_client.rpc import JsonRpcError
 
 
-def test_system_info(rpc) -> None:
-    system_info = rpc.get_system_info()
+@pytest.mark.asyncio
+async def test_system_info(rpc) -> None:
+    system_info = await rpc.get_system_info()
     assert "arch" in system_info
     assert "deltachat_core_version" in system_info
 
 
-def test_sleep(rpc) -> None:
-    """Test that long-running task does not block short-running task from completion."""
-    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
-        sleep_5_future = executor.submit(rpc.sleep, 5.0)
-        sleep_3_future = executor.submit(rpc.sleep, 3.0)
-        done, pending = concurrent.futures.wait(
-            [sleep_5_future, sleep_3_future],
-            return_when=concurrent.futures.FIRST_COMPLETED,
-        )
-        assert sleep_3_future in done
-        assert sleep_5_future in pending
-
-
-def test_email_address_validity(rpc) -> None:
+@pytest.mark.asyncio
+async def test_email_address_validity(rpc) -> None:
     valid_addresses = [
         "email@example.com",
         "36aa165ae3406424e0c61af17700f397cad3fe8ab83d682d0bddf3338a5dd52e@yggmail@yggmail",
@@ -35,16 +20,17 @@ def test_email_address_validity(rpc) -> None:
     invalid_addresses = ["email@", "example.com", "emai221"]
 
     for addr in valid_addresses:
-        assert rpc.check_email_validity(addr)
+        assert await rpc.check_email_validity(addr)
     for addr in invalid_addresses:
-        assert not rpc.check_email_validity(addr)
+        assert not await rpc.check_email_validity(addr)
 
 
-def test_acfactory(acfactory) -> None:
-    account = acfactory.new_configured_account()
+@pytest.mark.asyncio
+async def test_acfactory(acfactory) -> None:
+    account = await acfactory.new_configured_account()
     while True:
-        event = account.wait_for_event()
-        if event.kind == EventType.CONFIGURE_PROGRESS:
+        event = await account.wait_for_event()
+        if event.type == EventType.CONFIGURE_PROGRESS:
             assert event.progress != 0  # Progress 0 indicates error.
             if event.progress == 1000:  # Success
                 break
@@ -53,327 +39,208 @@ def test_acfactory(acfactory) -> None:
     print("Successful configuration")
 
 
-def test_configure_starttls(acfactory) -> None:
-    account = acfactory.new_preconfigured_account()
+@pytest.mark.asyncio
+async def test_account(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    # Use STARTTLS
-    account.set_config("mail_security", "2")
-    account.set_config("send_security", "2")
-    account.configure()
-    assert account.is_configured()
-
-
-def test_account(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_text("Hello!")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = bob.wait_for_event()
-        if event.kind == EventType.INCOMING_MSG:
+        event = await bob.wait_for_event()
+        if event.type == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
-    message = bob.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
+    message = await bob.get_message_by_id(msg_id)
+    snapshot = await message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
-    bob.mark_seen_messages([message])
+    await bob.mark_seen_messages([message])
 
     assert alice != bob
     assert repr(alice)
-    assert alice.get_info().level
-    assert alice.get_size()
-    assert alice.is_configured()
-    assert not alice.get_avatar()
-    assert alice.get_contact_by_addr(bob_addr) == alice_contact_bob
-    assert alice.get_contacts()
-    assert alice.get_contacts(snapshot=True)
+    assert (await alice.get_info()).level
+    assert await alice.get_size()
+    assert await alice.is_configured()
+    assert not await alice.get_avatar()
+    assert await alice.get_contact_by_addr(bob_addr) == alice_contact_bob
+    assert await alice.get_contacts()
+    assert await alice.get_contacts(snapshot=True)
     assert alice.self_contact
-    assert alice.get_chatlist()
-    assert alice.get_chatlist(snapshot=True)
-    assert alice.get_qr_code()
-    assert alice.get_fresh_messages()
-    assert alice.get_next_messages()
+    assert await alice.get_chatlist()
+    assert await alice.get_chatlist(snapshot=True)
+    assert await alice.get_qr_code()
+    await alice.get_fresh_messages()
+    await alice.get_fresh_messages_in_arrival_order()
 
-    # Test sending empty message.
-    assert len(bob.wait_next_messages()) == 0
-    alice_chat_bob.send_text("")
-    messages = bob.wait_next_messages()
-    assert len(messages) == 1
-    message = messages[0]
-    snapshot = message.get_snapshot()
-    assert snapshot.text == ""
-    bob.mark_seen_messages([message])
+    group = await alice.create_group("test group")
+    await group.add_contact(alice_contact_bob)
+    group_msg = await group.send_message(text="hello")
+    assert group_msg == await alice.get_message_by_id(group_msg.id)
+    assert group == await alice.get_chat_by_id(group.id)
+    await alice.delete_messages([group_msg])
 
-    group = alice.create_group("test group")
-    group.add_contact(alice_contact_bob)
-    group_msg = group.send_message(text="hello")
-    assert group_msg == alice.get_message_by_id(group_msg.id)
-    assert group == alice.get_chat_by_id(group.id)
-    alice.delete_messages([group_msg])
+    await alice.set_config("selfstatus", "test")
+    assert await alice.get_config("selfstatus") == "test"
+    await alice.update_config(selfstatus="test2")
+    assert await alice.get_config("selfstatus") == "test2"
 
-    alice.set_config("selfstatus", "test")
-    assert alice.get_config("selfstatus") == "test"
-    alice.update_config(selfstatus="test2")
-    assert alice.get_config("selfstatus") == "test2"
-
-    assert not alice.get_blocked_contacts()
-    alice_contact_bob.block()
-    blocked_contacts = alice.get_blocked_contacts()
+    assert not await alice.get_blocked_contacts()
+    await alice_contact_bob.block()
+    blocked_contacts = await alice.get_blocked_contacts()
     assert blocked_contacts
     assert blocked_contacts[0].contact == alice_contact_bob
 
-    bob.remove()
-    alice.stop_io()
+    await bob.remove()
+    await alice.stop_io()
 
 
-def test_chat(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio
+async def test_chat(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_text("Hello!")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = bob.wait_for_event()
-        if event.kind == EventType.INCOMING_MSG:
+        event = await bob.wait_for_event()
+        if event.type == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
-    message = bob.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
+    message = await bob.get_message_by_id(msg_id)
+    snapshot = await message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
-    bob_chat_alice = bob.get_chat_by_id(chat_id)
+    bob_chat_alice = await bob.get_chat_by_id(chat_id)
 
     assert alice_chat_bob != bob_chat_alice
     assert repr(alice_chat_bob)
-    alice_chat_bob.delete()
-    assert not bob_chat_alice.can_send()
-    bob_chat_alice.accept()
-    assert bob_chat_alice.can_send()
-    bob_chat_alice.block()
-    bob_chat_alice = snapshot.sender.create_chat()
-    bob_chat_alice.mute()
-    bob_chat_alice.unmute()
-    bob_chat_alice.pin()
-    bob_chat_alice.unpin()
-    bob_chat_alice.archive()
-    bob_chat_alice.unarchive()
+    await alice_chat_bob.delete()
+    await bob_chat_alice.accept()
+    await bob_chat_alice.block()
+    bob_chat_alice = await snapshot.sender.create_chat()
+    await bob_chat_alice.mute()
+    await bob_chat_alice.unmute()
+    await bob_chat_alice.pin()
+    await bob_chat_alice.unpin()
+    await bob_chat_alice.archive()
+    await bob_chat_alice.unarchive()
     with pytest.raises(JsonRpcError):  # can't set name for 1:1 chats
-        bob_chat_alice.set_name("test")
-    bob_chat_alice.set_ephemeral_timer(300)
-    bob_chat_alice.get_encryption_info()
+        await bob_chat_alice.set_name("test")
+    await bob_chat_alice.set_ephemeral_timer(300)
+    await bob_chat_alice.get_encryption_info()
 
-    group = alice.create_group("test group")
-    group.add_contact(alice_contact_bob)
-    group.get_qr_code()
+    group = await alice.create_group("test group")
+    await group.add_contact(alice_contact_bob)
+    await group.get_qr_code()
 
-    snapshot = group.get_basic_snapshot()
+    snapshot = await group.get_basic_snapshot()
     assert snapshot.name == "test group"
-    group.set_name("new name")
-    snapshot = group.get_full_snapshot()
+    await group.set_name("new name")
+    snapshot = await group.get_full_snapshot()
     assert snapshot.name == "new name"
 
-    msg = group.send_message(text="hi")
-    assert (msg.get_snapshot()).text == "hi"
-    group.forward_messages([msg])
+    msg = await group.send_message(text="hi")
+    assert (await msg.get_snapshot()).text == "hi"
+    await group.forward_messages([msg])
 
-    group.set_draft(text="test draft")
-    draft = group.get_draft()
+    await group.set_draft(text="test draft")
+    draft = await group.get_draft()
     assert draft.text == "test draft"
-    group.remove_draft()
-    assert not group.get_draft()
+    await group.remove_draft()
+    assert not await group.get_draft()
 
-    assert group.get_messages()
-    group.get_fresh_message_count()
-    group.mark_noticed()
-    assert group.get_contacts()
-    group.remove_contact(alice_chat_bob)
-    group.get_locations()
+    assert await group.get_messages()
+    await group.get_fresh_message_count()
+    await group.mark_noticed()
+    assert await group.get_contacts()
+    await group.remove_contact(alice_chat_bob)
+    await group.get_locations()
 
 
-def test_contact(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio
+async def test_contact(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
 
-    assert alice_contact_bob == alice.get_contact_by_id(alice_contact_bob.id)
+    assert alice_contact_bob == await alice.get_contact_by_id(alice_contact_bob.id)
     assert repr(alice_contact_bob)
-    alice_contact_bob.block()
-    alice_contact_bob.unblock()
-    alice_contact_bob.set_name("new name")
-    alice_contact_bob.get_encryption_info()
-    snapshot = alice_contact_bob.get_snapshot()
+    await alice_contact_bob.block()
+    await alice_contact_bob.unblock()
+    await alice_contact_bob.set_name("new name")
+    await alice_contact_bob.get_encryption_info()
+    snapshot = await alice_contact_bob.get_snapshot()
     assert snapshot.address == bob_addr
-    alice_contact_bob.create_chat()
+    await alice_contact_bob.create_chat()
 
 
-def test_message(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio
+async def test_message(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_text("Hello!")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = bob.wait_for_event()
-        if event.kind == EventType.INCOMING_MSG:
+        event = await bob.wait_for_event()
+        if event.type == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
-    message = bob.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
+    message = await bob.get_message_by_id(msg_id)
+    snapshot = await message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
-    assert not snapshot.is_bot
     assert repr(message)
 
     with pytest.raises(JsonRpcError):  # chat is not accepted
-        snapshot.chat.send_text("hi")
-    snapshot.chat.accept()
-    snapshot.chat.send_text("hi")
+        await snapshot.chat.send_text("hi")
+    await snapshot.chat.accept()
+    await snapshot.chat.send_text("hi")
 
-    message.mark_seen()
-    message.send_reaction("😎")
-    reactions = message.get_reactions()
-    assert reactions
-    snapshot = message.get_snapshot()
-    assert reactions == snapshot.reactions
+    await message.mark_seen()
+    await message.send_reaction("😎")
 
 
-def test_is_bot(acfactory) -> None:
-    """Test that we can recognize messages submitted by bots."""
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio
+async def test_bot(acfactory) -> None:
+    async def callback(e):
+        res.append(e)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
+    res = []
+    bot = await acfactory.new_configured_bot()
+    assert await bot.is_configured()
+    assert await bot.account.get_config("bot") == "1"
 
-    # Alice becomes a bot.
-    alice.set_config("bot", "1")
-    alice_chat_bob.send_text("Hello!")
+    bot.add_hook(callback, events.RawEvent(EventType.INFO))
+    info_event = AttrDict(account=bot.account, type=EventType.INFO, msg="info")
+    warn_event = AttrDict(account=bot.account, type=EventType.WARNING, msg="warning")
+    await bot._on_event(info_event)
+    await bot._on_event(warn_event)
+    assert info_event in res
+    assert warn_event not in res
+    assert len(res) == 1
 
-    while True:
-        event = bob.wait_for_event()
-        if event.kind == EventType.INCOMING_MSG:
-            msg_id = event.msg_id
-            message = bob.get_message_by_id(msg_id)
-            snapshot = message.get_snapshot()
-            assert snapshot.chat_id == event.chat_id
-            assert snapshot.text == "Hello!"
-            assert snapshot.is_bot
-            break
-
-
-def test_bot(acfactory) -> None:
-    mock = MagicMock()
-    user = (acfactory.get_online_accounts(1))[0]
-    bot = acfactory.new_configured_bot()
-    bot2 = acfactory.new_configured_bot()
-
-    assert bot.is_configured()
-    assert bot.account.get_config("bot") == "1"
-
-    hook = lambda e: mock.hook(e.msg_id) and None, events.RawEvent(EventType.INCOMING_MSG)
-    bot.add_hook(*hook)
-    event = acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
-    snapshot = bot.account.get_message_by_id(event.msg_id).get_snapshot()
-    assert not snapshot.is_bot
-    mock.hook.assert_called_once_with(event.msg_id)
-    bot.remove_hook(*hook)
-
-    def track(e):
-        mock.hook(e.message_snapshot.id)
-
-    mock.hook.reset_mock()
-    hook = track, events.NewMessage(r"hello")
-    bot.add_hook(*hook)
-    bot.add_hook(track, events.NewMessage(command="/help"))
-    event = acfactory.process_message(from_account=user, to_client=bot, text="hello")
-    mock.hook.assert_called_with(event.msg_id)
-    event = acfactory.process_message(from_account=user, to_client=bot, text="hello!")
-    mock.hook.assert_called_with(event.msg_id)
-    acfactory.process_message(from_account=bot2.account, to_client=bot, text="hello")
-    assert len(mock.hook.mock_calls) == 2  # bot messages are ignored between bots
-    acfactory.process_message(from_account=user, to_client=bot, text="hey!")
-    assert len(mock.hook.mock_calls) == 2
-    bot.remove_hook(*hook)
-
-    mock.hook.reset_mock()
-    acfactory.process_message(from_account=user, to_client=bot, text="hello")
-    event = acfactory.process_message(from_account=user, to_client=bot, text="/help")
-    mock.hook.assert_called_once_with(event.msg_id)
-
-
-def test_wait_next_messages(acfactory) -> None:
-    alice = acfactory.new_configured_account()
-
-    # Create a bot account so it does not receive device messages in the beginning.
-    bot = acfactory.new_preconfigured_account()
-    bot.set_config("bot", "1")
-    bot.configure()
-
-    # There are no old messages and the call returns immediately.
-    assert not bot.wait_next_messages()
-
-    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
-        # Bot starts waiting for messages.
-        next_messages_task = executor.submit(bot.wait_next_messages)
-
-        bot_addr = bot.get_config("addr")
-        alice_contact_bot = alice.create_contact(bot_addr, "Bob")
-        alice_chat_bot = alice_contact_bot.create_chat()
-        alice_chat_bot.send_text("Hello!")
-
-        next_messages = next_messages_task.result()
-        assert len(next_messages) == 1
-        snapshot = next_messages[0].get_snapshot()
-        assert snapshot.text == "Hello!"
-
-
-def test_import_export(acfactory, tmp_path) -> None:
-    alice = acfactory.new_configured_account()
-    alice.export_backup(tmp_path)
-
-    files = list(tmp_path.glob("*.tar"))
-    alice2 = acfactory.get_unconfigured_account()
-    alice2.import_backup(files[0])
-
-    assert alice2.manager.get_system_info()
-
-
-def test_openrpc_command_line() -> None:
-    """Test that "deltachat-rpc-server --openrpc" command returns an OpenRPC specification."""
-    out = subprocess.run(["deltachat-rpc-server", "--openrpc"], capture_output=True, check=True).stdout
-    openrpc = json.loads(out)
-    assert "openrpc" in openrpc
-    assert "methods" in openrpc
-
-
-def test_provider_info(rpc) -> None:
-    account_id = rpc.add_account()
-
-    provider_info = rpc.get_provider_info(account_id, "example.org")
-    assert provider_info["id"] == "example.com"
-
-    provider_info = rpc.get_provider_info(account_id, "uep7oiw4ahtaizuloith.org")
-    assert provider_info is None
-
-    # Test MX record resolution.
-    provider_info = rpc.get_provider_info(account_id, "github.com")
-    assert provider_info["id"] == "gmail"
-
-    # Disable MX record resolution.
-    rpc.set_config(account_id, "socks5_enabled", "1")
-    provider_info = rpc.get_provider_info(account_id, "github.com")
-    assert provider_info is None
+    res = []
+    bot.add_hook(callback, events.NewMessage(r"hello"))
+    snapshot1 = AttrDict(text="hello")
+    snapshot2 = AttrDict(text="hello, world")
+    snapshot3 = AttrDict(text="hey!")
+    for snapshot in [snapshot1, snapshot2, snapshot3]:
+        await bot._on_event(snapshot, events.NewMessage)
+    assert len(res) == 2
+    assert snapshot1 in res
+    assert snapshot2 in res
+    assert snapshot3 not in res

deltachat-rpc-client/tests/test_webxdc.py

@@ -1,45 +0,0 @@
-from deltachat_rpc_client import EventType
-
-
-def test_webxdc(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")
-
-    while True:
-        event = bob.wait_for_event()
-        if event.kind == EventType.INCOMING_MSG:
-            bob_chat_alice = bob.get_chat_by_id(event.chat_id)
-            message = bob.get_message_by_id(event.msg_id)
-            break
-
-    webxdc_info = message.get_webxdc_info()
-    assert webxdc_info == {
-        "document": None,
-        "icon": "icon.png",
-        "internetAccess": False,
-        "name": "Chess Board",
-        "sourceCodeUrl": None,
-        "summary": None,
-    }
-
-    status_updates = message.get_webxdc_status_updates()
-    assert status_updates == []
-
-    bob_chat_alice.accept()
-    message.send_webxdc_status_update({"payload": 42}, "")
-    message.send_webxdc_status_update({"payload": "Second update"}, "description")
-
-    status_updates = message.get_webxdc_status_updates()
-    assert status_updates == [
-        {"payload": 42, "serial": 1, "max_serial": 2},
-        {"payload": "Second update", "serial": 2, "max_serial": 2},
-    ]
-
-    status_updates = message.get_webxdc_status_updates(1)
-    assert status_updates == [
-        {"payload": "Second update", "serial": 2, "max_serial": 2},
-    ]

deltachat-rpc-client/tox.ini

@@ -2,32 +2,18 @@
 isolated_build = true
 envlist =
     py3
-    lint
 
 [testenv]
 commands =
-    pytest -n6 {posargs}
+    pytest {posargs}
 setenv =
 # Avoid stack overflow when Rust core is built without optimizations.
     RUST_MIN_STACK=8388608
 passenv =
-    CHATMAIL_DOMAIN
+    DCC_NEW_TMP_EMAIL
 deps =
     pytest
-    pytest-timeout
-    pytest-xdist
-
-[testenv:lint]
-skipsdist = True
-skip_install = True
-deps =
-    ruff
-    black
-commands =
-    black --quiet --check --diff src/ examples/ tests/
-    ruff src/ examples/ tests/
-
-[pytest]
-timeout = 300
-log_cli = true
-log_level = debug
+    pytest-async
+    pytest-asyncio
+    aiohttp
+    aiodns

deltachat-rpc-server/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.131.5"
+version = "1.103.0"
 description = "DeltaChat JSON-RPC server"
+authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"
 readme = "README.md"
 license = "MPL-2.0"
@@ -9,20 +10,17 @@ license = "MPL-2.0"
 keywords = ["deltachat", "chat", "openpgp", "email", "encryption"]
 categories = ["cryptography", "std", "email"]
 
+[[bin]]
+name = "deltachat-rpc-server"
+
 [dependencies]
-deltachat-jsonrpc = { path = "../deltachat-jsonrpc", default-features = false }
-deltachat = { path = "..", default-features = false }
+deltachat-jsonrpc = { path = "../deltachat-jsonrpc" }
 
 anyhow = "1"
 env_logger = { version = "0.10.0" }
-futures-lite = "2.0.0"
+futures-lite = "1.12.0"
 log = "0.4"
-serde_json = "1.0.105"
+serde_json = "1.0.89"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.33.0", features = ["io-std"] }
-tokio-util = "0.7.9"
-yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }
-
-[features]
-default = ["vendored"]
-vendored = ["deltachat-jsonrpc/vendored"]
+tokio = { version = "1.22.0", features = ["io-std"] }
+yerpc = { version = "0.3.1", features = ["anyhow_expose"] }

deltachat-rpc-server/README.md

@@ -1,37 +0,0 @@
-# Delta Chat RPC server
-
-This program provides a [JSON-RPC 2.0](https://www.jsonrpc.org/specification) interface to DeltaChat
-over standard I/O.
-
-## Install
-
-To download binary pre-builds check the [releases page](https://github.com/deltachat/deltachat-core-rust/releases).
-Rename the downloaded binary to `deltachat-rpc-server` and add it to your `PATH`.
-
-To install from source run:
-
-```sh
-cargo install --git https://github.com/deltachat/deltachat-core-rust/ deltachat-rpc-server
-```
-
-The `deltachat-rpc-server` executable will be installed into `$HOME/.cargo/bin` that should be available
-in your `PATH`.
-
-## Usage
-
-To use just run `deltachat-rpc-server` command. The accounts folder will be created in the current
-working directory unless `DC_ACCOUNTS_PATH` is set:
-
-```sh
-export DC_ACCOUNTS_PATH=$HOME/delta/
-deltachat-rpc-server
-```
-
-The common use case for this program is to create bindings to use Delta Chat core from programming
-languages other than Rust, for example:
-
-1. Python: https://github.com/deltachat/deltachat-core-rust/tree/master/deltachat-rpc-client/
-2. Go: https://github.com/deltachat/deltachat-rpc-client-go/
-
-Run `deltachat-rpc-server --version` to check the version of the server.
-Run `deltachat-rpc-server --openrpc` to get [OpenRPC](https://open-rpc.org/) specification of the provided JSON-RPC API.

deltachat-rpc-server/src/bin/deltachat-rpc-server/main.rs

@@ -0,0 +1,68 @@
+///! Delta Chat core RPC server.
+///!
+///! It speaks JSON Lines over stdio.
+use std::path::PathBuf;
+
+use anyhow::Result;
+use deltachat_jsonrpc::api::events::event_to_json_rpc_notification;
+use deltachat_jsonrpc::api::{Accounts, CommandApi};
+use futures_lite::stream::StreamExt;
+use tokio::io::{self, AsyncBufReadExt, BufReader};
+use tokio::task::JoinHandle;
+use yerpc::{RpcClient, RpcSession};
+
+#[tokio::main(flavor = "multi_thread")]
+async fn main() -> Result<()> {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+
+    let path = std::env::var("DC_ACCOUNTS_PATH").unwrap_or_else(|_| "accounts".to_string());
+    log::info!("Starting with accounts directory `{}`.", path);
+    let accounts = Accounts::new(PathBuf::from(&path)).await?;
+    let events = accounts.get_event_emitter();
+
+    log::info!("Creating JSON-RPC API.");
+    let state = CommandApi::new(accounts);
+
+    let (client, mut out_receiver) = RpcClient::new();
+    let session = RpcSession::new(client.clone(), state);
+
+    // Events task converts core events to JSON-RPC notifications.
+    let events_task: JoinHandle<Result<()>> = tokio::spawn(async move {
+        while let Some(event) = events.recv().await {
+            let event = event_to_json_rpc_notification(event);
+            client.send_notification("event", Some(event)).await?;
+        }
+        Ok(())
+    });
+
+    // Send task prints JSON responses to stdout.
+    let send_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
+        while let Some(message) = out_receiver.next().await {
+            let message = serde_json::to_string(&message)?;
+            log::trace!("RPC send {}", message);
+            println!("{}", message);
+        }
+        Ok(())
+    });
+
+    // Receiver task reads JSON requests from stdin.
+    let recv_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
+        let stdin = io::stdin();
+        let mut lines = BufReader::new(stdin).lines();
+        while let Some(message) = lines.next_line().await? {
+            log::trace!("RPC recv {}", message);
+            session.handle_incoming(&message).await;
+        }
+        log::info!("EOF reached on stdin");
+        Ok(())
+    });
+
+    // Wait for the end of stdin.
+    recv_task.await??;
+
+    // Shutdown the server.
+    send_task.abort();
+    events_task.abort();
+
+    Ok(())
+}

deltachat-rpc-server/src/main.rs

@@ -1,151 +0,0 @@
-//! Delta Chat core RPC server.
-//!
-//! It speaks JSON Lines over stdio.
-use std::env;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use anyhow::{anyhow, Context as _, Result};
-use deltachat::constants::DC_VERSION_STR;
-use deltachat_jsonrpc::api::{Accounts, CommandApi};
-use futures_lite::stream::StreamExt;
-use tokio::io::{self, AsyncBufReadExt, BufReader};
-use yerpc::RpcServer as _;
-
-#[cfg(target_family = "unix")]
-use tokio::signal::unix as signal_unix;
-
-use tokio::sync::RwLock;
-use tokio::task::JoinHandle;
-use tokio_util::sync::CancellationToken;
-use yerpc::{RpcClient, RpcSession};
-
-#[tokio::main(flavor = "multi_thread")]
-async fn main() {
-    let r = main_impl().await;
-    // From tokio documentation:
-    // "For technical reasons, stdin is implemented by using an ordinary blocking read on a separate
-    // thread, and it is impossible to cancel that read. This can make shutdown of the runtime hang
-    // until the user presses enter."
-    std::process::exit(if r.is_ok() { 0 } else { 1 });
-}
-
-async fn main_impl() -> Result<()> {
-    let mut args = env::args_os();
-    let _program_name = args.next().context("no command line arguments found")?;
-    if let Some(first_arg) = args.next() {
-        if first_arg.to_str() == Some("--version") {
-            if let Some(arg) = args.next() {
-                return Err(anyhow!("Unrecognized argument {:?}", arg));
-            }
-            eprintln!("{}", &*DC_VERSION_STR);
-            return Ok(());
-        } else if first_arg.to_str() == Some("--openrpc") {
-            if let Some(arg) = args.next() {
-                return Err(anyhow!("Unrecognized argument {:?}", arg));
-            }
-            println!("{}", CommandApi::openrpc_specification()?);
-            return Ok(());
-        } else {
-            return Err(anyhow!("Unrecognized option {:?}", first_arg));
-        }
-    }
-    if let Some(arg) = args.next() {
-        return Err(anyhow!("Unrecognized argument {:?}", arg));
-    }
-
-    // Install signal handlers early so that the shutdown is graceful starting from here.
-    let _ctrl_c = tokio::signal::ctrl_c();
-    #[cfg(target_family = "unix")]
-    let mut sigterm = signal_unix::signal(signal_unix::SignalKind::terminate())?;
-
-    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
-
-    let path = std::env::var("DC_ACCOUNTS_PATH").unwrap_or_else(|_| "accounts".to_string());
-    log::info!("Starting with accounts directory `{}`.", path);
-    let writable = true;
-    let accounts = Accounts::new(PathBuf::from(&path), writable).await?;
-
-    log::info!("Creating JSON-RPC API.");
-    let accounts = Arc::new(RwLock::new(accounts));
-    let state = CommandApi::from_arc(accounts.clone());
-
-    let (client, mut out_receiver) = RpcClient::new();
-    let session = RpcSession::new(client.clone(), state.clone());
-    let main_cancel = CancellationToken::new();
-
-    // Send task prints JSON responses to stdout.
-    let cancel = main_cancel.clone();
-    let send_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        let _cancel_guard = cancel.clone().drop_guard();
-        loop {
-            let message = tokio::select! {
-                _ = cancel.cancelled() => break,
-                message = out_receiver.next() => match message {
-                    None => break,
-                    Some(message) => serde_json::to_string(&message)?,
-                }
-            };
-            log::trace!("RPC send {}", message);
-            println!("{message}");
-        }
-        Ok(())
-    });
-
-    let cancel = main_cancel.clone();
-    let sigterm_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        #[cfg(target_family = "unix")]
-        {
-            let _cancel_guard = cancel.clone().drop_guard();
-            tokio::select! {
-                _ = cancel.cancelled() => (),
-                _ = sigterm.recv() => {
-                    log::info!("got SIGTERM");
-                }
-            }
-        }
-        let _ = cancel;
-        Ok(())
-    });
-
-    // Receiver task reads JSON requests from stdin.
-    let cancel = main_cancel.clone();
-    let recv_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        let _cancel_guard = cancel.clone().drop_guard();
-        let stdin = io::stdin();
-        let mut lines = BufReader::new(stdin).lines();
-
-        loop {
-            let message = tokio::select! {
-                _ = cancel.cancelled() => break,
-                _ = tokio::signal::ctrl_c() => {
-                    log::info!("got ctrl-c event");
-                    break;
-                }
-                message = lines.next_line() => match message? {
-                    None => {
-                        log::info!("EOF reached on stdin");
-                        break;
-                    }
-                    Some(message) => message,
-                }
-            };
-            log::trace!("RPC recv {}", message);
-            let session = session.clone();
-            tokio::spawn(async move {
-                session.handle_incoming(&message).await;
-            });
-        }
-        Ok(())
-    });
-
-    main_cancel.cancelled().await;
-    accounts.read().await.stop_io().await;
-    drop(accounts);
-    drop(state);
-    send_task.await??;
-    sigterm_task.await??;
-    recv_task.await??;
-
-    Ok(())
-}

deltachat_derive/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "deltachat_derive"
 version = "2.0.0"
+authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL-2.0"
 
@@ -8,5 +9,5 @@ license = "MPL-2.0"
 proc-macro = true
 
 [dependencies]
-syn = "2"
+syn = "1"
 quote = "1"