try to reproduce (#4707)

Version 1.5.0 is yanked.

.gitattributes

@@ -2,6 +2,14 @@
 # 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

.github/dependabot.yml

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

.github/mergeable.yml

@@ -1,26 +0,0 @@
-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,48 +1,61 @@
+# 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:
-      - master
-      - staging
-      - trying
+      - main
 
 env:
   RUSTFLAGS: -Dwarnings
-   
+
 jobs:
+  lint_rust:
+    name: Lint Rust
+    runs-on: ubuntu-latest
+    env:
+      RUSTUP_TOOLCHAIN: 1.73.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
 
-  fmt:
-    name: Rustfmt
+  cargo_deny:
+    name: cargo deny
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
+      - uses: EmbarkStudios/cargo-deny-action@v1
         with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add rustfmt
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-      - run: cargo fmt --all -- --check
+          arguments: --all-features --workspace
+          command: check
+          command-arguments: "-Dwarnings"
 
-  run_clippy:
+  provider_database:
+    name: Check provider database
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-            toolchain: stable
-            components: clippy
-            override: true
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace --tests --examples --benches --features repl -- -D warnings
+      - name: Check provider database
+        run: scripts/update-provider-database.sh
 
   docs:
     name: Rust doc comments
@@ -52,111 +65,215 @@ 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
       - name: Rustdoc
         run: cargo doc --document-private-items --no-deps
 
-  build_and_test:
-    name: Build and test
+  rust_tests:
+    name: Rust tests
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            rust: 1.73.0
+          - os: windows-latest
+            rust: 1.73.0
+          - os: macos-latest
+            rust: 1.73.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
-            rust: 1.64.0
-            python: 3.9
-          - os: windows-latest
-            rust: 1.64.0
-            python: false # Python bindings compilation on Windows is not supported.
+            python: 3.12
+          - os: macos-latest
+            python: 3.12
+
+          # PyPy tests
+          - os: ubuntu-latest
+            python: pypy3.10
+          - os: macos-latest
+            python: pypy3.10
 
-          # Minimum Supported Rust Version = 1.63.0
-          #
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
-          # built.
+          # built. Test it with minimum supported Rust version.
           - os: ubuntu-latest
-            rust: 1.63.0
             python: 3.7
+
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@master
+      - uses: actions/checkout@v3
 
-    - name: Install ${{ matrix.rust }}
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        override: true
+      - name: Download libdeltachat.a
+        uses: actions/download-artifact@v3
+        with:
+          name: ${{ matrix.os }}-libdeltachat.a
+          path: target/debug
 
-    - name: Cache rust cargo artifacts
-      uses: swatinem/rust-cache@v2
+      - name: Install python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python }}
 
-    - name: check
-      run: cargo check --all --bins --examples --tests --features repl --benches
+      - name: Install tox
+        run: pip install tox
 
-    - name: tests
-      run: cargo test --all
+      - 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: test cargo vendor
-      run: cargo vendor
+  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: install python
-      if: ${{ matrix.python }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.python }}
+          # PyPy tests
+          - os: ubuntu-latest
+            python: pypy3.10
+          - os: macos-latest
+            python: pypy3.10
 
-    - name: install tox
-      if: ${{ matrix.python }}
-      run: pip install tox
+          # Minimum Supported Python Version = 3.7
+          - os: ubuntu-latest
+            python: 3.7
 
-    - name: build C library
-      if: ${{ matrix.python }}
-      run: cargo build -p deltachat_ffi --features jsonrpc
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
 
-    - 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 python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python }}
 
-    - name: build deltachat-rpc-server
-      if: ${{ matrix.python }}
-      run: cargo build -p deltachat-rpc-server
+      - name: Install tox
+        run: pip install tox
 
-    - name: add deltachat-rpc-server to path
-      if: ${{ matrix.python }}
-      run: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH
+      - name: Download deltachat-rpc-server
+        uses: actions/download-artifact@v3
+        with:
+          name: ${{ matrix.os }}-deltachat-rpc-server
+          path: target/debug
 
-    - 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,lint
+      - name: Make deltachat-rpc-server executable
+        if: ${{ matrix.os != 'windows-latest' }}
+        run: chmod +x target/debug/deltachat-rpc-server
 
-    - 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: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH
 
-    - 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
+      - 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

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

@@ -0,0 +1,168 @@
+# 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,3 +1,6 @@
+# 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,29 +1,28 @@
-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-18.04
+    name: "Package @deltachat/jsonrpc-client and upload to download.delta.chat"
+    runs-on: ubuntu-20.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: '16'
-      - name: get tag
+          node-version: "16"
+      - name: Get tag
         id: tag
         uses: dawidd6/action-get-tag@v1
         continue-on-error: true
-      - name: Get Pullrequest ID
+      - name: Get Pull Request ID
         id: prepare
         run: |
           tag=${{ steps.tag.outputs.tag }}
@@ -38,14 +37,13 @@ jobs:
           npm --version
           node --version
           echo $DELTACHAT_JSONRPC_TAR_GZ
-      - name: install dependencies without running scripts
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm install --ignore-scripts
-      - name: package
+      - 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
         run: |
-          cd deltachat-jsonrpc/typescript
           npm run build
           npm pack .
           ls -lah
@@ -65,13 +63,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: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
 
 env:
   CARGO_TERM_COLOR: always
@@ -22,20 +22,19 @@ jobs:
       - name: Add Rust cache
         uses: Swatinem/rust-cache@v2
       - name: npm install
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm install
+        working-directory: deltachat-jsonrpc/typescript
+        run: npm install
       - name: Build TypeScript, run Rust tests, generate bindings
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm run build
+        working-directory: deltachat-jsonrpc/typescript
+        run: npm run build
       - name: Run integration tests
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm run test
+        working-directory: deltachat-jsonrpc/typescript
+        run: npm run test
         env:
-          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+          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
       - name: Run linter
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm run prettier:check
+        working-directory: deltachat-jsonrpc/typescript
+        run: npm run prettier:check

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

@@ -1,32 +0,0 @@
-# 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,34 +1,39 @@
+# 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:
-      - master
+      - main
 
 jobs:
   generate:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Use Node.js 16.x
-      uses: actions/setup-node@v3
-      with:
-        node-version: 16.x
+      - name: Use Node.js 16.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16.x
 
-    - name: npm install and generate documentation
-      run: |
-        cd node
-        npm i --ignore-scripts
-        npx typedoc
-        mv docs js
+      - name: npm install and generate documentation
+        working-directory: node
+        run: |
+          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,25 +1,24 @@
-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: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [macos-latest, windows-latest]
     steps:
       - name: Checkout
         uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: '16'
+          node-version: "16"
       - name: System info
         run: |
           rustc -vV
@@ -47,13 +46,12 @@ jobs:
 
       - name: Install dependencies & build
         if: steps.cache.outputs.cache-hit != 'true'
-        run: |
-          cd node
-          npm install --verbose
+        working-directory: node
+        run: npm install --verbose
 
       - name: Build Prebuild
+        working-directory: node
         run: |
-          cd node
           npm run prebuildify
           tar -zcvf "${{ matrix.os }}.tar.gz" -C prebuilds .
 
@@ -63,23 +61,94 @@ jobs:
           name: ${{ matrix.os }}
           path: node/${{ matrix.os }}.tar.gz
 
-  pack-module:
-    needs: prebuild
-    name: 'Package deltachat-node and upload to download.delta.chat'
-    runs-on: ubuntu-18.04
+  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 at the time of the writing (2023-06-04): https://packages.debian.org/buster/libc6
+    # Ubuntu 18.04 is at the End of Standard Support since June 2023, but it contains glibc 2.27,
+    # so we are using it to support Ubuntu 18.04 setups that are still not upgraded.
+    container: ubuntu:18.04
     steps:
-      - name: install tree
+      # 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: "16"
+      - 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
+    steps:
+      - name: Install tree
         run: sudo apt install tree
       - name: Checkout
         uses: actions/checkout@v3
       - uses: actions/setup-node@v2
         with:
-          node-version: '16'
-      - name: get tag
+          node-version: "16"
+      - name: Get tag
         id: tag
         uses: dawidd6/action-get-tag@v1
         continue-on-error: true
-      - name: Get Pullrequest ID
+      - name: Get Pull Request ID
         id: prepare
         run: |
           tag=${{ steps.tag.outputs.tag }}
@@ -97,43 +166,43 @@ jobs:
           npm --version
           node --version
           echo $DELTACHAT_NODE_TAR_GZ
-      - name: Download ubuntu prebuild
+      - name: Download Linux prebuild
         uses: actions/download-artifact@v1
         with:
-          name: ubuntu-18.04
-      - name: Download macos prebuild
+          name: linux
+      - 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 ubuntu-18.04/ubuntu-18.04.tar.gz -C node/prebuilds
+          tar -xvzf linux/linux.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 ubuntu-18.04 macos-latest windows-latest
-      - name: install dependencies without running scripts
+          rm -rf linux 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
@@ -148,12 +217,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,25 +1,33 @@
-name: 'node.js tests'
+# 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
+
 on:
   pull_request:
   push:
     branches:
-      - master
-      - staging
-      - trying
+      - main
 
 jobs:
   tests:
-    name: 'tests'
+    name: Tests
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
     steps:
       - name: Checkout
         uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: '16'
+          node-version: "16"
       - name: System info
         run: |
           rustc -vV
@@ -47,25 +55,13 @@ jobs:
 
       - name: Install dependencies & build
         if: steps.cache.outputs.cache-hit != 'true'
-        run: |
-          cd node
-          npm install --verbose
+        working-directory: node
+        run: npm install --verbose
 
       - name: Test
         timeout-minutes: 10
-        if: runner.os != 'Windows'
-        run: |
-          cd node
-          npm run test
+        working-directory: node
+        run: npm run test
         env:
-          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
-          NODE_OPTIONS: '--force-node-api-uncaught-exceptions-policy=true'
-      - 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 }}
-          NODE_OPTIONS: '--force-node-api-uncaught-exceptions-policy=true'
+          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
+          NODE_OPTIONS: "--force-node-api-uncaught-exceptions-policy=true"

.github/workflows/repl.yml

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

.github/workflows/upload-docs.yml

@@ -3,25 +3,22 @@ name: Build & Deploy Documentation on rs.delta.chat
 on:
   push:
     branches:
-      - master
-      - docs-gh-action
+      - main
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
-    - 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/"
-
+      - 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/"

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

@@ -1,27 +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:
-      - master
-      - docs-gh-action
+      - main
 
 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
+      - 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,6 +1,7 @@
 /target
 **/*.rs.bk
 /build
+/dist
 
 # ignore vi temporaries
 *~
@@ -18,6 +19,9 @@ python/.eggs
 __pycache__
 python/src/deltachat/capi*.so
 python/.venv/
+python/venv/
+venv/
+env/
 
 python/liveconfig*
 

CONTRIBUTING.md

@@ -0,0 +1,115 @@
+# 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}"))
+```
+
+### 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,9 @@
 [package]
 name = "deltachat"
-version = "1.107.0"
+version = "1.127.2"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.63"
+rust-version = "1.70"
 
 [profile.dev]
 debug = 0
@@ -13,88 +13,98 @@ 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-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.6", 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
+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"] }
 backtrace = "0.3"
-base64 = "0.20"
-bitflags = "1.3"
+base64 = "0.21"
+brotli = { version = "3.4", default-features=false, features = ["std"] }
 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"
-image = { version = "0.24.5", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
+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 }
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"
-log = {version = "0.4.16", optional = true }
 mailparse = "0.14"
-native-tls = "0.2"
-num_cpus = "1.15"
-num-derive = "0.3"
+mime = "0.3.17"
+num_cpus = "1.16"
+num-derive = "0.4"
 num-traits = "0.2"
-once_cell = "1.17.0"
-percent-encoding = "2.2"
-pgp = { version = "0.9", default-features = false }
-pretty_env_logger = { version = "0.4", optional = true }
-quick-xml = "0.27"
-r2d2 = "0.8"
-r2d2_sqlite = "0.20"
+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"
 rand = "0.8"
-regex = "1.7"
-rusqlite = { version = "0.27", features = ["sqlcipher"] }
+regex = "1.9"
+reqwest = { version = "0.11.20", features = ["json"] }
+rusqlite = { version = "0.29", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
-rustyline = { version = "10", optional = true }
-sanitize-filename = "0.4"
+sanitize-filename = "0.5"
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10"
 sha2 = "0.10"
 smallvec = "1"
-strum = "0.24"
-strum_macros = "0.24"
-thiserror = "1"
-toml = "0.5"
-url = "2"
-uuid = { version = "1", features = ["serde", "v4"] }
-fast-socks5 = "0.8"
-humansize = "2"
-qrcodegen = "1.7.0"
+strum = "0.25"
+strum_macros = "0.25"
 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"] }
+thiserror = "1"
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 tokio-io-timeout = "1.2.0"
-reqwest = { version = "0.11.13", features = ["json"] }
-async_zip = { version = "0.0.9", default-features = false, features = ["deflate"] }
+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.7"
+url = "2"
+uuid = { version = "1", features = ["serde", "v4"] }
 
 [dev-dependencies]
 ansi_term = "0.12.0"
-criterion = { version = "0.4.0", features = ["async_tokio"] }
-futures-lite = "1.12"
+criterion = { version = "0.5.1", features = ["async_tokio"] }
+futures-lite = "2.0.0"
 log = "0.4"
-pretty_env_logger = "0.4"
+pretty_env_logger = "0.5"
 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 = [
@@ -103,20 +113,10 @@ members = [
   "deltachat-jsonrpc",
   "deltachat-rpc-server",
   "deltachat-ratelimit",
+  "deltachat-repl",
   "format-flowed",
 ]
 
-[[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,14 +141,15 @@ 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 http://mozilla.org/MPL/2.0/.
+  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

README.md

@@ -1,8 +1,16 @@
-# Delta Chat Rust
+<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>
 
-> Deltachat-core written in 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>
 
-[![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)
+<p align="center">
+The core library for Delta Chat, written in Rust
+</p>
 
 ## Installing Rust and Cargo
 
@@ -19,10 +27,19 @@ $ curl https://sh.rustup.rs -sSf | sh
 Compile and run Delta Chat Core command line utility, using `cargo`:
 
 ```
-$ RUST_LOG=repl=info cargo run --example repl --features repl -- ~/deltachat-db
+$ RUST_LOG=deltachat_repl=info cargo run -p deltachat-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):
 
 ```
@@ -104,7 +121,7 @@ $ cargo build -p deltachat_ffi --release
 
 - `DCC_MIME_DEBUG`: if set outgoing and incoming message will be printed 
 
-- `RUST_LOG=repl=info,async_imap=trace,async_smtp=trace`: enable IMAP and
+- `RUST_LOG=deltachat_repl=info,async_imap=trace,async_smtp=trace`: enable IMAP and
 SMTP tracing in addition to info messages.
 
 ### Expensive tests
@@ -158,10 +175,12 @@ Language bindings are available for:
 
 - **C** \[[📂 source](./deltachat-ffi) | [📚 docs](https://c.delta.chat)\]
 - **Node.js** 
-  - 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)\]
+  - 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)\]
 - **Python** \[[📂 source](./python) | [📦 pypi](https://pypi.org/project/deltachat) | [📚 docs](https://py.delta.chat)\]
-- **Go**[^1] \[[📂 source](https://github.com/deltachat/go-deltachat/)\]
+- **Go**
+  - over jsonrpc: \[[📂 source](https://github.com/deltachat/deltachat-rpc-client-go/)\]
+  - over cffi[^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

@@ -0,0 +1,21 @@
+# 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 ''`.

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 {}\naddr{}@example.org\n", i, i))
+        .map(|i| format!("Name {i}\naddr{i}@example.org\n"))
         .collect::<Vec<String>>()
         .join("");
 

benches/create_account.rs

@@ -8,7 +8,8 @@ async fn create_accounts(n: u32) {
     let dir = tempdir().unwrap();
     let p: PathBuf = dir.path().join("accounts");
 
-    let mut accounts = Accounts::new(p.clone()).await.unwrap();
+    let writable = true;
+    let mut accounts = Accounts::new(p.clone(), writable).await.unwrap();
 
     for expected_id in 2..n {
         let id = accounts.add_account().await.unwrap();

benches/get_chat_msgs.rs

@@ -14,7 +14,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, 0).await.ok());
+        black_box(chat::get_chat_msgs(&context, *c).await.ok());
     }
 }
 

benches/send_events.rs

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,79 @@
+# 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,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.107.0"
+version = "1.127.2"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
@@ -17,18 +17,18 @@ crate-type = ["cdylib", "staticlib"]
 deltachat = { path = "../", default-features = false }
 deltachat-jsonrpc = { path = "../deltachat-jsonrpc", optional = true }
 libc = "0.2"
-human-panic = "1"
+human-panic = { version = "1", default-features = false }
 num-traits = "0.2"
 serde_json = "1.0"
 tokio = { version = "1", features = ["rt-multi-thread"] }
 anyhow = "1"
 thiserror = "1"
-rand = "0.7"
-once_cell = "1.17.0"
+rand = "0.8"
+once_cell = "1.18.0"
+yerpc = { version = "0.5.1", features = ["anyhow_expose"] }
 
 [features]
 default = ["vendored"]
 vendored = ["deltachat/vendored"]
-nightly = ["deltachat/nightly"]
-jsonrpc = ["deltachat-jsonrpc"]
+jsonrpc = ["dep: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_keyring_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_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,14 +1,24 @@
 
+: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: #e0e0e0;
+	background-color: var(--accent);
 	border: 0;
 	padding: 1em;
 	border-radius: 6px;
 }
 
 code {
-	background-color: #e0e0e0;
+	background-color: var(--accent);
 	padding-left: .5em;
 	padding-right: .5em;
 	border-radius: 6px;

deltachat-ffi/deltachat.h

@@ -24,6 +24,8 @@ typedef struct _dc_provider  dc_provider_t;
 typedef struct _dc_event     dc_event_t;
 typedef struct _dc_event_emitter dc_event_emitter_t;
 typedef struct _dc_jsonrpc_instance dc_jsonrpc_instance_t;
+typedef struct _dc_backup_provider dc_backup_provider_t;
+typedef struct _dc_http_response dc_http_response_t;
 
 // Alias for backwards compatibility, use dc_event_emitter_t instead.
 typedef struct _dc_event_emitter dc_accounts_event_emitter_t;
@@ -71,7 +73,6 @@ typedef struct _dc_event_emitter dc_accounts_event_emitter_t;
  *
  * The example above uses "pthreads",
  * however, you can also use anything else for thread handling.
- * All deltachat-core functions, unless stated otherwise, are thread-safe.
  *
  * Now you can **configure the context:**
  *
@@ -141,6 +142,72 @@ typedef struct _dc_event_emitter dc_accounts_event_emitter_t;
  * ~~~
  *
  *
+ * ## Thread safety
+ *
+ * All deltachat-core functions, unless stated otherwise, are thread-safe.
+ * In particular, it is safe to pass the same dc_context_t pointer
+ * to multiple functions running concurrently in different threads.
+ *
+ * All the functions are guaranteed not to use the reference passed to them
+ * after returning. If the function spawns a long-running process,
+ * such as dc_configure() or dc_imex(), it will ensure that the objects
+ * passed to them are not deallocated as long as they are needed.
+ * For example, it is safe to call dc_imex(context, ...) and
+ * call dc_context_unref(context) immediately after return from dc_imex().
+ * It is however **not safe** to call dc_context_unref(context) concurrently
+ * until dc_imex() returns, because dc_imex() may have not increased
+ * the reference count of dc_context_t yet.
+ *
+ * This means that the context may be still in use after
+ * dc_context_unref() call.
+ * For example, it is possible to start the import/export process,
+ * call dc_context_unref(context) immediately after
+ * and observe #DC_EVENT_IMEX_PROGRESS events via the event emitter.
+ * Once dc_get_next_event() returns NULL,
+ * it is safe to terminate the application.
+ *
+ * It is recommended to create dc_context_t in the main thread
+ * and only call dc_context_unref() once other threads that may use it,
+ * such as the event loop thread, are terminated.
+ * Common mistake is to use dc_context_unref() as a way
+ * to cause dc_get_next_event() return NULL and terminate event loop this way.
+ * If event loop thread is inside a function taking dc_context_t
+ * as an argument at the moment dc_context_unref() is called on the main thread,
+ * the behavior is undefined.
+ *
+ * Recommended way to safely terminate event loop
+ * and shutdown the application is
+ * to use a boolean variable
+ * indicating that the event loop should stop
+ * and check it in the event loop thread
+ * every time before calling dc_get_next_event().
+ * To terminate the event loop, main thread should:
+ * 1. Notify background threads,
+ *    such as event loop (blocking in dc_get_next_event())
+ *    and message processing loop (blocking in dc_wait_next_msgs()),
+ *    that they should terminate by atomically setting the
+ *    boolean flag in the memory
+ *    shared between the main thread and background loop threads.
+ * 2. Call dc_stop_io() or dc_accounts_stop_io(), depending
+ *    on whether a single account or account manager is used.
+ *    Stopping I/O is guaranteed to emit at least one event
+ *    and interrupt the event loop even if it was blocked on dc_get_next_event().
+ *    Stopping I/O is guaranteed to interrupt a single dc_wait_next_msgs().
+ * 3. Wait until the event loop thread notices the flag,
+ *    exits the event loop and terminates.
+ * 4. Call dc_context_unref() or dc_accounts_unref().
+ * 5. Keep calling dc_get_next_event() in a loop until it returns NULL,
+ *    indicating that the contexts are deallocated.
+ * 6. Terminate the application.
+ *
+ * When using C API via FFI in runtimes that use automatic memory management,
+ * such as CPython, JVM or Node.js, take care to ensure the correct
+ * shutdown order and avoid calling dc_context_unref() or dc_accounts_unref()
+ * on the objects still in use in other threads,
+ * e.g. by keeping a reference to the wrapper object.
+ * The details depend on the runtime being used.
+ *
+ *
  * ## Class reference
  *
  * For a class reference, see the "Classes" link atop.
@@ -234,6 +301,19 @@ dc_context_t*   dc_context_new_closed        (const char* dbfile);
 int             dc_context_open              (dc_context_t *context, const char* passphrase);
 
 
+/**
+ * Changes the passphrase on the open database.
+ * Existing database must already be encrypted and the passphrase cannot be NULL or empty.
+ * It is impossible to encrypt unencrypted database with this method and vice versa.
+ *
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @param passphrase The new passphrase.
+ * @return 1 on success, 0 on error.
+ */
+int             dc_context_change_passphrase (dc_context_t* context, const char* passphrase);
+
+
 /**
  * Returns 1 if database is open.
  *
@@ -304,7 +384,12 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 /**
  * Configure the context. The configuration is handled by key=value pairs as:
  *
- * - `addr`         = address to display (always needed)
+ * - `addr`         = Email address to use for configuration.
+ *                    If dc_configure() fails this is not the email address actually in use.
+ *                    Use `configured_addr` to find out the email address actually in use.
+ * - `configured_addr` = Email address actually in use.
+ *                    Unless for testing, do not set this value using dc_set_config().
+ *                    Instead, set `addr` and call dc_configure().
  * - `mail_server`  = IMAP-server, guessed if left out
  * - `mail_user`    = IMAP-username, guessed if left out
  * - `mail_pw`      = IMAP-password (always needed)
@@ -353,17 +438,19 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    0=watch all folders normally (default)
  *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
  * - `show_emails`  = DC_SHOW_EMAILS_OFF (0)=
- *                    show direct replies to chats only (default),
+ *                    show direct replies to chats only,
  *                    DC_SHOW_EMAILS_ACCEPTED_CONTACTS (1)=
  *                    also show all mails of confirmed contacts,
  *                    DC_SHOW_EMAILS_ALL (2)=
- *                    also show mails of unconfirmed contacts.
+ *                    also show mails of unconfirmed contacts (default).
  * - `key_gen_type` = DC_KEY_GEN_DEFAULT (0)=
  *                    generate recommended key type (default),
  *                    DC_KEY_GEN_RSA2048 (1)=
  *                    generate RSA 2048 keypair
  *                    DC_KEY_GEN_ED25519 (2)=
- *                    generate Ed25519 keypair
+ *                    generate Curve25519 keypair
+ *                    DC_KEY_GEN_RSA4096 (3)=
+ *                    generate RSA 4096 keypair
  * - `save_mime_headers` = 1=save mime headers
  *                    and make dc_get_mime_headers() work for subsequent calls,
  *                    0=do not save mime headers (default)
@@ -394,11 +481,25 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    If no type is prefixed, the videochat is handled completely in a browser.
  * - `bot`          = Set to "1" if this is a bot.
  *                    Prevents adding the "Device messages" and "Saved messages" chats,
- *                    adds Auto-Submitted header to outgoing messages
- *                    and accepts contact requests automatically (calling dc_accept_chat() is not needed for bots).
+ *                    adds Auto-Submitted header to outgoing messages,
+ *                    accepts contact requests automatically (calling dc_accept_chat() is not needed for bots)
+ *                    and does not cut large incoming text messages.
+ * - `last_msg_id` = database ID of the last message processed by the bot.
+ *                   This ID and IDs below it are guaranteed not to be returned
+ *                   by dc_get_next_msgs() and dc_wait_next_msgs().
+ *                   The value is updated automatically
+ *                   when dc_markseen_msgs() is called,
+ *                   but the bot can also set it manually if it processed
+ *                   the message but does not want to mark it as seen.
+ *                   For most bots calling `dc_markseen_msgs()` is the
+ *                   recommended way to update this value
+ *                   even for self-sent messages.
  * - `fetch_existing_msgs` = 1=fetch most recent existing messages on configure (default),
  *                    0=do not fetch existing messages on configure.
  *                    In both cases, existing recipients are added to the contact database.
+ * - `disable_idle` = 1=disable IMAP IDLE even if the server supports it,
+ *                    0=use IMAP IDLE if the server supports it.
+ *                    This is a developer option used for testing polling used as an IDLE fallback.
  * - `download_limit` = Messages up to this number of bytes are downloaded automatically.
  *                    For larger messages, only the header is downloaded and a placeholder is shown.
  *                    These messages can be downloaded fully using dc_download_full_msg() later.
@@ -407,6 +508,16 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    to not mess up with non-delivery-reports or read-receipts.
  *                    0=no limit (default).
  *                    Changes affect future messages only.
+ * - `gossip_period` = How often to gossip Autocrypt keys in chats with multiple recipients, in
+ *                    seconds. 2 days by default.
+ *                    This is not supposed to be changed by UIs and only used for testing.
+ * - `verified_one_on_one_chats` = Feature flag for verified 1:1 chats; the UI should set it
+ *                    to 1 if it supports verified 1:1 chats.
+ *                    Regardless of this setting, `dc_chat_is_protected()` returns true while the key is verified,
+ *                    and when the key changes, an info message is posted into the chat.
+ *                    0=Nothing else happens when the key changes.
+ *                    1=After the key changed, `dc_chat_can_send()` returns false and `dc_chat_is_protection_broken()` returns true
+ *                    until `dc_accept_chat()` is called.
  * - `ui.*`         = All keys prefixed by `ui.` can be used by the user-interfaces for system-specific purposes.
  *                    The prefix should be followed by the system and maybe subsystem,
  *                    e.g. `ui.desktop.foo`, `ui.desktop.linux.bar`, `ui.android.foo`, `ui.dc40.bar`, `ui.bot.simplebot.baz`.
@@ -612,7 +723,7 @@ int             dc_all_work_done             (dc_context_t* context);
  * While dc_configure() returns immediately,
  * the started configuration-job may take a while.
  *
- * During configuration, #DC_EVENT_CONFIGURE_PROGRESS events are emmited;
+ * During configuration, #DC_EVENT_CONFIGURE_PROGRESS events are emitted;
  * they indicate a successful configuration as well as errors
  * and may be used to create a progress bar.
  *
@@ -731,7 +842,7 @@ void            dc_maybe_network             (dc_context_t* context);
  * @param context The context as created by dc_context_new().
  * @param addr The e-mail address of the user. This must match the
  *    configured_addr setting of the context as well as the UID of the key.
- * @param public_data ASCII armored public key.
+ * @param public_data Ignored, actual public key is extracted from secret_data.
  * @param secret_data ASCII armored secret key.
  * @return 1 on success, 0 on failure.
  */
@@ -785,7 +896,8 @@ int             dc_preconfigure_keypair        (dc_context_t* context, const cha
  *     - if the flag DC_GCL_ADD_ALLDONE_HINT is set, DC_CHAT_ID_ALLDONE_HINT
  *       is added as needed.
  * @param query_str An optional query for filtering the list. Only chats matching this query
- *     are returned. Give NULL for no filtering.
+ *     are returned. Give NULL for no filtering. When `is:unread` is contained in the query,
+ *     the chatlist is filtered such that only chats with unread messages show up.
  * @param query_id An optional contact ID for filtering the list. Only chats including this contact ID
  *     are returned. Give 0 for no filtering.
  * @return A chatlist as an dc_chatlist_t object.
@@ -869,7 +981,7 @@ uint32_t        dc_get_chat_id_by_contact_id (dc_context_t* context, uint32_t co
  * @param context The context object as returned from dc_context_new().
  * @param chat_id The chat ID to send the message to.
  * @param msg The message object to send to the chat defined by the chat ID.
- *     On succcess, msg_id and state of the object are set up,
+ *     On success, msg_id and state of the object are set up,
  *     The function does not take ownership of the object,
  *     so you have to free it using dc_msg_unref() as usual.
  * @return The ID of the message that is being prepared.
@@ -880,7 +992,7 @@ uint32_t        dc_prepare_msg               (dc_context_t* context, uint32_t ch
 /**
  * Send a message defined by a dc_msg_t object to a chat.
  *
- * Sends the event #DC_EVENT_MSGS_CHANGED on succcess.
+ * Sends the event #DC_EVENT_MSGS_CHANGED on success.
  * However, this does not imply, the message really reached the recipient -
  * sending may be delayed e.g. due to network problems. However, from your
  * view, you're done with the message. Sooner or later it will find its way.
@@ -909,7 +1021,7 @@ uint32_t        dc_prepare_msg               (dc_context_t* context, uint32_t ch
  * @param chat_id The chat ID to send the message to.
  *     If dc_prepare_msg() was called before, this parameter can be 0.
  * @param msg The message object to send to the chat defined by the chat ID.
- *     On succcess, msg_id of the object is set up,
+ *     On success, msg_id of the object is set up,
  *     The function does not take ownership of the object,
  *     so you have to free it using dc_msg_unref() as usual.
  * @return The ID of the message that is about to be sent. 0 in case of errors.
@@ -926,7 +1038,7 @@ uint32_t        dc_send_msg                  (dc_context_t* context, uint32_t ch
  * @param chat_id The chat ID to send the message to.
  *     If dc_prepare_msg() was called before, this parameter can be 0.
  * @param msg The message object to send to the chat defined by the chat ID.
- *     On succcess, msg_id of the object is set up,
+ *     On success, msg_id of the object is set up,
  *     The function does not take ownership of the object,
  *     so you have to free it using dc_msg_unref() as usual.
  * @return The ID of the message that is about to be sent. 0 in case of errors.
@@ -937,7 +1049,7 @@ uint32_t        dc_send_msg_sync                  (dc_context_t* context, uint32
 /**
  * Send a simple text message a given chat.
  *
- * Sends the event #DC_EVENT_MSGS_CHANGED on succcess.
+ * Sends the event #DC_EVENT_MSGS_CHANGED on success.
  * However, this does not imply, the message really reached the recipient -
  * sending may be delayed e.g. due to network problems. However, from your
  * view, you're done with the message. Sooner or later it will find its way.
@@ -1025,7 +1137,7 @@ dc_reactions_t* dc_get_msg_reactions (dc_context_t *context, int msg_id);
  *
  * In JS land, that would be mapped to something as:
  * ```
- * success = window.webxdc.sendUpdate('{"action":"move","src":"A3","dest":"B4"}', 'move A3 B4');
+ * success = window.webxdc.sendUpdate('{payload: {"action":"move","src":"A3","dest":"B4"}}', 'move A3 B4');
  * ```
  * `context` and `msg_id` are not needed in JS as those are unique within a webxdc instance.
  * See dc_get_webxdc_status_updates() for the receiving counterpart.
@@ -1146,7 +1258,7 @@ void            dc_set_draft                 (dc_context_t* context, uint32_t ch
  *     // not now and not when this code is executed again
  *     dc_add_device_msg(context, "update-123", NULL);
  * } else {
- *     // welcome message was not added now, this is an oder installation,
+ *     // welcome message was not added now, this is an older installation,
  *     // add a changelog
  *     dc_add_device_msg(context, "update-123", changelog_msg);
  * }
@@ -1159,7 +1271,7 @@ uint32_t        dc_add_device_msg            (dc_context_t* context, const char*
 
 /**
  * Check if a device-message with a given label was ever added.
- * Device-messages can be added dc_add_device_msg().
+ * Device-messages can be added with dc_add_device_msg().
  *
  * @memberof dc_context_t
  * @param context The context object.
@@ -1243,6 +1355,20 @@ int             dc_get_msg_cnt               (dc_context_t* context, uint32_t ch
 int             dc_get_fresh_msg_cnt         (dc_context_t* context, uint32_t chat_id);
 
 
+/**
+ * Returns a list of similar chats.
+ *
+ * @warning This is an experimental API which may change or be removed in the future.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as returned from dc_context_new().
+ * @param chat_id The ID of the chat for which to find similar chats.
+ * @return The list of similar chats.
+ *     On errors, NULL is returned.
+ *     Must be freed using dc_chatlist_unref() when no longer used.
+ */
+dc_chatlist_t*     dc_get_similar_chatlist   (dc_context_t* context, uint32_t chat_id);
+
 
 /**
  * Estimate the number of messages that will be deleted
@@ -1282,6 +1408,56 @@ int             dc_estimate_deletion_cnt    (dc_context_t* context, int from_ser
 dc_array_t*     dc_get_fresh_msgs            (dc_context_t* context);
 
 
+/**
+ * Returns the message IDs of all messages of any chat
+ * with a database ID higher than `last_msg_id` config value.
+ *
+ * This function is intended for use by bots.
+ * Self-sent messages, device messages,
+ * messages from contact requests
+ * and muted chats are included,
+ * but messages from explicitly blocked contacts
+ * and chats are ignored.
+ *
+ * This function may be called as a part of event loop
+ * triggered by DC_EVENT_INCOMING_MSG if you are only interested
+ * in the incoming messages.
+ * Otherwise use a separate message processing loop
+ * calling dc_wait_next_msgs() in a separate thread.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as returned from dc_context_new().
+ * @return An array of message IDs, must be dc_array_unref()'d when no longer used.
+ *     On errors, the list is empty. NULL is never returned.
+ */
+dc_array_t*     dc_get_next_msgs             (dc_context_t* context);
+
+
+/**
+ * Waits for notification of new messages
+ * and returns an array of new message IDs.
+ * See the documentation for dc_get_next_msgs()
+ * for the details of return value.
+ *
+ * This function waits for internal notification of
+ * a new message in the database and returns afterwards.
+ * Notification is also sent when I/O is started
+ * to allow processing new messages
+ * and when I/O is stopped using dc_stop_io() or dc_accounts_stop_io()
+ * to allow for manual interruption of the message processing loop.
+ * The function may return an empty array if there are
+ * no messages after notification,
+ * which may happen on start or if the message is quickly deleted
+ * after adding it to the database.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as returned from dc_context_new().
+ * @return An array of message IDs, must be dc_array_unref()'d when no longer used.
+ *     On errors, the list is empty. NULL is never returned.
+ */
+dc_array_t*     dc_wait_next_msgs            (dc_context_t* context);
+
+
 /**
  * Mark all messages in a chat as _noticed_.
  * _Noticed_ messages are no longer _fresh_ and do not count as being unseen
@@ -1324,6 +1500,7 @@ dc_array_t*     dc_get_chat_media            (dc_context_t* context, uint32_t ch
  * Typically used to implement the "next" and "previous" buttons
  * in a gallery or in a media player.
  *
+ * @deprecated Deprecated 2023-10-03, use dc_get_chat_media() and navigate the returned array instead.
  * @memberof dc_context_t
  * @param context The context object as returned from dc_context_new().
  * @param msg_id The ID of the current message from which the next or previous message should be searched.
@@ -1342,24 +1519,6 @@ dc_array_t*     dc_get_chat_media            (dc_context_t* context, uint32_t ch
 uint32_t        dc_get_next_media            (dc_context_t* context, uint32_t msg_id, int dir, int msg_type, int msg_type2, int msg_type3);
 
 
-/**
- * Enable or disable protection against active attacks.
- * To enable protection, it is needed that all members are verified;
- * if this condition is met, end-to-end-encryption is always enabled
- * and only the verified keys are used.
- *
- * Sends out #DC_EVENT_CHAT_MODIFIED on changes
- * and #DC_EVENT_MSGS_CHANGED if a status message was sent.
- *
- * @memberof dc_context_t
- * @param context The context object as returned from dc_context_new().
- * @param chat_id The ID of the chat to change the protection for.
- * @param protect 1=protect chat, 0=unprotect chat
- * @return 1=success, 0=error, e.g. some members may be unverified
- */
-int             dc_set_chat_protection       (dc_context_t* context, uint32_t chat_id, int protect);
-
-
 /**
  * Set chat visibility to pinned, archived or normal.
  *
@@ -1553,24 +1712,12 @@ uint32_t        dc_create_group_chat         (dc_context_t* context, int protect
  * Create a new broadcast list.
  *
  * Broadcast lists are similar to groups on the sending device,
- * however, recipients get the messages in normal one-to-one chats
- * and will not be aware of other members.
+ * however, recipients get the messages in a read-only chat
+ * and will see who the other members are.
  *
- * 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.
+ * 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.
  *
  * @memberof dc_context_t
  * @param context The context object.
@@ -1881,6 +2028,11 @@ int             dc_resend_msgs               (dc_context_t* context, const uint3
  * 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.
  *
  * @memberof dc_context_t
@@ -2100,8 +2252,7 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
 
 /**
  * Import/export things.
- * During backup import/export IO must not be started,
- * if needed stop IO using dc_accounts_stop_io() or dc_stop_io() first.
+ *
  * What to do is defined by the _what_ parameter which may be one of the following:
  *
  * - **DC_IMEX_EXPORT_BACKUP** (11) - Export a backup to the directory given as `param1`
@@ -2109,8 +2260,7 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
  *   the backup is not encrypted.
  *   The backup contains all contacts, chats, images and other data and device independent settings.
  *   The backup does not contain device dependent settings as ringtones or LED notification settings.
- *   The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
- *   the format is `delta-chat-<day>-<number>.tar`
+ *   The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.tar`.
  *
  * - **DC_IMEX_IMPORT_BACKUP** (12) - `param1` is the file (not: directory) to import. `param2` is the passphrase.
  *   The file is normally created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
@@ -2123,6 +2273,7 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
  *
  * - **DC_IMEX_IMPORT_SELF_KEYS** (2) - Import private keys found in the directory given as `param1`.
  *   The last imported key is made the default keys unless its name contains the string `legacy`. Public keys are not imported.
+ *   If `param1` is a filename, import the private key from the file and make it the default.
  *
  * While dc_imex() returns immediately, the started job may take a while,
  * you can stop it using dc_stop_ongoing_process(). During execution of the job,
@@ -2295,6 +2446,7 @@ void            dc_stop_ongoing_process      (dc_context_t* context);
 #define         DC_QR_FPR_MISMATCH           220 // id=contact
 #define         DC_QR_FPR_WITHOUT_ADDR       230 // test1=formatted fingerprint
 #define         DC_QR_ACCOUNT                250 // text1=domain
+#define         DC_QR_BACKUP                 251
 #define         DC_QR_WEBRTC_INSTANCE        260 // text1=domain, text2=instance pattern
 #define         DC_QR_ADDR                   320 // id=contact
 #define         DC_QR_TEXT                   330 // text1=text
@@ -2320,7 +2472,7 @@ void            dc_stop_ongoing_process      (dc_context_t* context);
  *   ask whether to verify the contact;
  *   if so, start the protocol with dc_join_securejoin().
  *
- * - DC_QR_ASK_VERIFYGROUP withdc_lot_t::text1=Group name:
+ * - DC_QR_ASK_VERIFYGROUP with dc_lot_t::text1=Group name:
  *   ask whether to join the group;
  *   if so, start the protocol with dc_join_securejoin().
  *
@@ -2340,6 +2492,10 @@ void            dc_stop_ongoing_process      (dc_context_t* context);
  *   ask the user if they want to create an account on the given domain,
  *   if so, call dc_set_config_from_qr() and then dc_configure().
  *
+ * - DC_QR_BACKUP:
+ *   ask the user if they want to set up a new device.
+ *   If so, pass the qr-code to dc_receive_backup().
+ *
  * - DC_QR_WEBRTC_INSTANCE with dc_lot_t::text1=domain:
  *   ask the user if they want to use the given service for video chats;
  *   if so, call dc_set_config_from_qr().
@@ -2630,6 +2786,123 @@ char* dc_get_last_error (dc_context_t* context);
 void dc_str_unref (char* str);
 
 
+/**
+ * @class dc_backup_provider_t
+ *
+ * Set up another device.
+ */
+
+/**
+ * Creates an object for sending a backup to another device.
+ *
+ * The backup is sent to through a peer-to-peer channel which is bootstrapped
+ * by a QR-code.  The backup contains the entire state of the account
+ * including credentials.  This can be used to setup a new device.
+ *
+ * This is a blocking call as some preparations are made like e.g. exporting
+ * the database.  Once this function returns, the backup is being offered to
+ * remote devices.  To wait until one device received the backup, use
+ * dc_backup_provider_wait().  Alternatively abort the operation using
+ * dc_stop_ongoing_process().
+ *
+ * During execution of the job #DC_EVENT_IMEX_PROGRESS is sent out to indicate
+ * state and progress.
+ *
+ * @memberof dc_backup_provider_t
+ * @param context The context.
+ * @return Opaque object for sending the backup.
+ *    On errors, NULL is returned and dc_get_last_error() returns an error that
+ *    should be shown to the user.
+ */
+dc_backup_provider_t* dc_backup_provider_new (dc_context_t* context);
+
+
+/**
+ * Returns the QR code text that will offer the backup to other devices.
+ *
+ * The QR code contains a ticket which will validate the backup and provide
+ * authentication for both the provider and the recipient.
+ *
+ * The scanning device should call the scanned text to dc_check_qr().  If
+ * dc_check_qr() returns DC_QR_BACKUP, the backup transfer can be started using
+ * dc_get_backup().
+ *
+ * @memberof dc_backup_provider_t
+ * @param backup_provider The backup provider object as created by
+ *    dc_backup_provider_new().
+ * @return The text that should be put in the QR code.
+ *    On errors an empty string is returned, NULL is never returned.
+ *    the returned string must be released using dc_str_unref() after usage.
+ */
+char* dc_backup_provider_get_qr (const dc_backup_provider_t* backup_provider);
+
+
+/**
+ * Returns the QR code SVG image that will offer the backup to other devices.
+ *
+ * This works like dc_backup_provider_qr() but returns the text of a rendered
+ * SVG image containing the QR code.
+ *
+ * @memberof dc_backup_provider_t
+ * @param backup_provider The backup provider object as created by
+ *    dc_backup_provider_new().
+ * @return The QR code rendered as SVG.
+ *    On errors an empty string is returned, NULL is never returned.
+ *    the returned string must be released using dc_str_unref() after usage.
+ */
+char* dc_backup_provider_get_qr_svg (const dc_backup_provider_t* backup_provider);
+
+/**
+ * Waits for the sending to finish.
+ *
+ * This is a blocking call and should only be called once.
+ *
+ * @memberof dc_backup_provider_t
+ * @param backup_provider The backup provider object as created by
+ *    dc_backup_provider_new().  If NULL is given nothing is done.
+ */
+void dc_backup_provider_wait (dc_backup_provider_t* backup_provider);
+
+/**
+ * Frees a dc_backup_provider_t object.
+ *
+ * If the provider has not yet finished, as indicated by
+ * dc_backup_provider_wait() or the #DC_EVENT_IMEX_PROGRESS event with value
+ * of 0 (failed) or 1000 (succeeded), this will also abort any in-progress
+ * transfer.  If this aborts the provider a #DC_EVENT_IMEX_PROGRESS event with
+ * value 0 (failed) will be emitted.
+ *
+ * @memberof dc_backup_provider_t
+ * @param backup_provider The backup provider object as created by
+ *    dc_backup_provider_new().
+ */
+void dc_backup_provider_unref (dc_backup_provider_t* backup_provider);
+
+/**
+ * Gets a backup offered by a dc_backup_provider_t object on another device.
+ *
+ * This function is called on a device that scanned the QR code offered by
+ * dc_backup_sender_qr() or dc_backup_sender_qr_svg().  Typically this is a
+ * different device than that which provides the backup.
+ *
+ * This call will block while the backup is being transferred and only
+ * complete on success or failure.  Use dc_stop_ongoing_process() to abort it
+ * early.
+ *
+ * During execution of the job #DC_EVENT_IMEX_PROGRESS is sent out to indicate
+ * state and progress.  The process is finished when the event emits either 0
+ * or 1000, 0 means it failed and 1000 means it succeeded.  These events are
+ * for showing progress and informational only, success and failure is also
+ * shown in the return code of this function.
+ *
+ * @memberof dc_context_t
+ * @param context The context.
+ * @param qr The qr code text, dc_check_qr() must have returned DC_QR_BACKUP
+ *    on this text.
+ * @return 0=failure, 1=success.
+ */
+int dc_receive_backup (dc_context_t* context, const char* qr);
+
 /**
  * @class dc_accounts_t
  *
@@ -2672,12 +2945,15 @@ void dc_str_unref (char* str);
  * @param dir The directory to create the context-databases in.
  *     If the directory does not exist,
  *     dc_accounts_new() will try to create it.
+ * @param writable Whether the returned account manager is writable, i.e. calling these functions on
+ *     it is possible: dc_accounts_add_account(), dc_accounts_add_closed_account(),
+ *     dc_accounts_migrate_account(), dc_accounts_remove_account(), dc_accounts_select_account().
  * @return An account manager object.
  *     The object must be passed to the other account manager functions
  *     and must be freed using dc_accounts_unref() after usage.
  *     On errors, NULL is returned.
  */
-dc_accounts_t* dc_accounts_new                  (const char* os_name, const char* dir);
+dc_accounts_t* dc_accounts_new                  (const char* dir, int writable);
 
 
 /**
@@ -3184,7 +3460,7 @@ dc_lot_t*        dc_chatlist_get_summary     (const dc_chatlist_t* chatlist, siz
  * it takes the chat ID and the message ID as returned by dc_chatlist_get_chat_id() and dc_chatlist_get_msg_id()
  * as arguments. The chatlist object itself is not needed directly.
  *
- * This maybe useful if you convert the complete object into a different represenation
+ * This maybe useful if you convert the complete object into a different representation
  * as done e.g. in the node-bindings.
  * If you have access to the chatlist object in some way, using this function is not recommended,
  * use dc_chatlist_get_summary() in this case instead.
@@ -3458,7 +3734,6 @@ int             dc_chat_can_send              (const dc_chat_t* chat);
  * Check if a chat is protected.
  * Protected chats contain only verified members and encryption is always enabled.
  * Protected chats are created using dc_create_group_chat() by setting the 'protect' parameter to 1.
- * The status can be changed using dc_set_chat_protection().
  *
  * @memberof dc_chat_t
  * @param chat The chat object.
@@ -3467,6 +3742,26 @@ int             dc_chat_can_send              (const dc_chat_t* chat);
 int             dc_chat_is_protected         (const dc_chat_t* chat);
 
 
+/**
+ * Checks if the chat was protected, and then an incoming message broke this protection.
+ *
+ * This function is only useful if the UI enabled the `verified_one_on_one_chats` feature flag,
+ * otherwise it will return false for all chats.
+ *
+ * 1:1 chats are automatically set as protected when a contact is verified.
+ * When a message comes in that is not encrypted / signed correctly,
+ * the chat is automatically set as unprotected again.
+ * dc_chat_is_protection_broken() will return true until dc_accept_chat() is called.
+ *
+ * The UI should let the user confirm that this is OK with a message like
+ * `Bob sent a message from another device. Tap to learn more` and then call dc_accept_chat().
+ * @memberof dc_chat_t
+ * @param chat The chat object.
+ * @return 1=chat protection broken, 0=otherwise.
+ */
+int             dc_chat_is_protection_broken (const dc_chat_t* chat);
+
+
 /**
  * Check if locations are sent to the chat
  * at the time the object was created using dc_get_chat().
@@ -3671,7 +3966,7 @@ int64_t          dc_msg_get_received_timestamp (const dc_msg_t* msg);
  * Get the message time used for sorting.
  * This function returns the timestamp that is used for sorting the message
  * into lists as returned e.g. by dc_get_chat_msgs().
- * This may be the reveived time, the sending time or another time.
+ * This may be the received time, the sending time or another time.
  *
  * To get the receiving time, use dc_msg_get_received_timestamp().
  * To get the sending time, use dc_msg_get_timestamp().
@@ -3724,16 +4019,17 @@ char*           dc_msg_get_text               (const dc_msg_t* msg);
  */
 char*           dc_msg_get_subject            (const dc_msg_t* msg);
 
+
 /**
- * Find out full path, file name and extension of the file associated with a
- * message.
+ * Find out full path of the file associated with a message.
  *
  * Typically files are associated with images, videos, audios, documents.
  * Plain text messages do not have a file.
+ * File name may be mangled. To obtain the original attachment filename use dc_msg_get_filename().
  *
  * @memberof dc_msg_t
  * @param msg The message object.
- * @return The full path, the file name, and the extension of the file associated with the message.
+ * @return The full path (with file name and extension) of the file associated with the message.
  *     If there is no file associated with the message, an empty string is returned.
  *     NULL is never returned and the returned value must be released using dc_str_unref().
  */
@@ -3741,14 +4037,13 @@ char*           dc_msg_get_file               (const dc_msg_t* msg);
 
 
 /**
- * Get a base file name without the path. The base file name includes the extension; the path
- * is not returned. To get the full path, use dc_msg_get_file().
+ * Get an original attachment filename, with extension but without the path. To get the full path,
+ * use dc_msg_get_file().
  *
  * @memberof dc_msg_t
  * @param msg The message object.
- * @return The base file name plus the extension without part. If there is no file
- *     associated with the message, an empty string is returned. The returned
- *     value must be released using dc_str_unref().
+ * @return The attachment filename. If there is no file associated with the message, an empty string
+ *     is returned. The returned value must be released using dc_str_unref().
  */
 char*           dc_msg_get_filename           (const dc_msg_t* msg);
 
@@ -4061,7 +4356,7 @@ int             dc_msg_is_forwarded           (const dc_msg_t* msg);
  * Check if the message is an informational message, created by the
  * device or by another users. Such messages are not "typed" by the user but
  * created due to other actions,
- * e.g. dc_set_chat_name(), dc_set_chat_profile_image(), dc_set_chat_protection()
+ * e.g. dc_set_chat_name(), dc_set_chat_profile_image(),
  * or dc_add_contact_to_chat().
  *
  * These messages are typically shown in the center of the chat view,
@@ -4327,6 +4622,18 @@ void            dc_msg_set_text               (dc_msg_t* msg, const char* text);
 void            dc_msg_set_html               (dc_msg_t* msg, const char* html);
 
 
+/**
+ * Sets the email's subject. If it's empty, a default subject
+ * will be used (e.g. `Message from Alice` or `Re: <last subject>`).
+ * This does not alter any information in the database.
+ *
+ * @memberof dc_msg_t
+ * @param msg The message object.
+ * @param subject The new subject.
+ */
+void            dc_msg_set_subject            (dc_msg_t* msg, const char* subject);
+
+
 /**
  * Set different sender name for a message.
  * This overrides the name set by the dc_set_config()-option `displayname`.
@@ -4743,7 +5050,12 @@ int             dc_contact_is_verified       (dc_contact_t* contact);
 /**
  * Return the address that verified a contact
  *
- * The UI may use this in addition to a checkmark showing the verification status
+ * The UI may use this in addition to a checkmark showing the verification status.
+ * In case of verification chains,
+ * the last contact in the chain is shown.
+ * This is because of privacy reasons, but also as it would not help the user
+ * to see a unknown name here - where one can mostly always ask the shown name
+ * as it is directly known.
  *
  * @memberof dc_contact_t
  * @param contact The contact object.
@@ -4751,6 +5063,7 @@ int             dc_contact_is_verified       (dc_contact_t* contact);
  *    A string containing the verifiers address. If it is the same address as the contact itself,
  *    we verified the contact ourself. If it is an empty string, we don't have verifier 
  *    information or the contact is not verified.
+ * @deprecated 2023-09-28, use dc_contact_get_verifier_id instead
  */
 char*           dc_contact_get_verifier_addr       (dc_contact_t* contact);
 
@@ -4763,7 +5076,7 @@ char*           dc_contact_get_verifier_addr       (dc_contact_t* contact);
  * @memberof dc_contact_t
  * @param contact The contact object.
  * @return 
- *    The `ContactId` of the verifiers address. If it is the same address as the contact itself,
+ *    The contact ID of the verifier. If it is DC_CONTACT_ID_SELF,
  *    we verified the contact ourself. If it is 0, we don't have verifier information or 
  *    the contact is not verified.
  */
@@ -4863,6 +5176,72 @@ int             dc_provider_get_status                (const dc_provider_t* prov
 void            dc_provider_unref                     (dc_provider_t* provider);
 
 
+/**
+ * Return an HTTP(S) GET response.
+ * This function can be used to download remote content for HTML emails.
+ *
+ * @memberof dc_context_t
+ * @param context The context object to take proxy settings from.
+ * @param url HTTP or HTTPS URL.
+ * @return The response must be released using dc_http_response_unref() after usage.
+ *     NULL is returned on errors.
+ */
+dc_http_response_t*     dc_get_http_response      (const dc_context_t* context, const char* url);
+
+
+/**
+ * @class dc_http_response_t
+ *
+ * An object containing an HTTP(S) GET response.
+ * Created by dc_get_http_response().
+ */
+
+
+/**
+ * Returns HTTP response MIME type as a string, e.g. "text/plain" or "text/html".
+ *
+ * @memberof dc_http_response_t
+ * @param response HTTP response as returned by dc_get_http_response().
+ * @return The string which must be released using dc_str_unref() after usage. May be NULL.
+ */
+char*                   dc_http_response_get_mimetype (const dc_http_response_t* response);
+
+/**
+ * Returns HTTP response encoding, e.g. "utf-8".
+ *
+ * @memberof dc_http_response_t
+ * @param response HTTP response as returned by dc_get_http_response().
+ * @return The string which must be released using dc_str_unref() after usage. May be NULL.
+ */
+char*                   dc_http_response_get_encoding (const dc_http_response_t* response);
+
+/**
+ * Returns HTTP response contents.
+ *
+ * @memberof dc_http_response_t
+ * @param response HTTP response as returned by dc_get_http_response().
+ * @return The blob which must be released using dc_str_unref() after usage. NULL is never returned.
+ */
+uint8_t*                dc_http_response_get_blob     (const dc_http_response_t* response);
+
+/**
+ * Returns HTTP response content size.
+ *
+ * @memberof dc_http_response_t
+ * @param response HTTP response as returned by dc_get_http_response().
+ * @return The blob size.
+ */
+size_t                  dc_http_response_get_size     (const dc_http_response_t* response);
+
+/**
+ * Free an HTTP response object.
+ *
+ * @memberof dc_http_response_t
+ * @param response HTTP response as returned by dc_get_http_response().
+ */
+void                    dc_http_response_unref        (const dc_http_response_t* response);
+
+
 /**
  * @class dc_lot_t
  *
@@ -5340,7 +5719,6 @@ void            dc_reactions_unref       (dc_reactions_t* reactions);
  */
 
 
-
 /**
  * @class dc_jsonrpc_instance_t
  *
@@ -5389,6 +5767,17 @@ void dc_jsonrpc_request(dc_jsonrpc_instance_t* jsonrpc_instance, const char* req
  */
 char* dc_jsonrpc_next_response(dc_jsonrpc_instance_t* jsonrpc_instance);
 
+/**
+ * Make a JSON-RPC call and return a response.
+ *
+ * @memberof dc_jsonrpc_instance_t
+ * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
+ * @param input JSON-RPC request.
+ * @return JSON-RPC response as string, must be freed using dc_str_unref() after usage.
+ *     If there is no response, NULL is returned.
+ */
+char* dc_jsonrpc_blocking_call(dc_jsonrpc_instance_t* jsonrpc_instance, const char *input);
+
 /**
  * @class dc_event_emitter_t
  *
@@ -5577,6 +5966,14 @@ void dc_event_unref(dc_event_t* event);
  */
 #define DC_EVENT_IMAP_MESSAGE_MOVED   105
 
+/**
+ * Emitted before going into IDLE on the Inbox folder.
+ *
+ * @param data1 0
+ * @param data2 0
+ */
+#define DC_EVENT_IMAP_INBOX_IDLE 106
+
 /**
  * Emitted when a new blob file was successfully written
  *
@@ -5671,7 +6068,7 @@ void dc_event_unref(dc_event_t* event);
 #define DC_EVENT_INCOMING_MSG             2005
 
 /**
- * Downloading a bunch of messages just finished. This is an experimental
+ * Downloading a bunch of messages just finished. This is an
  * event to allow the UI to only show one notification per message bunch,
  * instead of cluttering the user with many notifications.
  * For each of the msg_ids, an additional #DC_EVENT_INCOMING_MSG event was emitted before.
@@ -5728,6 +6125,15 @@ void dc_event_unref(dc_event_t* event);
 #define DC_EVENT_MSG_READ                 2015
 
 
+/**
+ * A single message is deleted.
+ *
+ * @param data1 (int) chat_id
+ * @param data2 (int) msg_id
+ */
+#define DC_EVENT_MSG_DELETED              2016
+
+
 /**
  * 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.
@@ -5906,6 +6312,7 @@ void dc_event_unref(dc_event_t* event);
 #define DC_KEY_GEN_DEFAULT 0
 #define DC_KEY_GEN_RSA2048 1
 #define DC_KEY_GEN_ED25519 2
+#define DC_KEY_GEN_RSA4096 3
 
 
 /**
@@ -6329,7 +6736,7 @@ void dc_event_unref(dc_event_t* event);
 ///
 /// Used in status messages.
 ///
-/// @deperecated 2022-09-10
+/// @deprecated 2022-09-10
 #define DC_STR_EPHEMERAL_MINUTE           77
 
 /// "Message deletion timer is set to 1 hour."
@@ -6389,15 +6796,6 @@ void dc_event_unref(dc_event_t* event);
 /// Used in error strings.
 #define DC_STR_ERROR_NO_NETWORK           87
 
-/// "Chat protection enabled."
-///
-
-/// @deprecated Deprecated, replaced by DC_STR_MSG_YOU_ENABLED_PROTECTION and DC_STR_MSG_PROTECTION_ENABLED_BY.
-#define DC_STR_PROTECTION_ENABLED         88
-
-/// @deprecated Deprecated, replaced by DC_STR_MSG_YOU_DISABLED_PROTECTION and DC_STR_MSG_PROTECTION_DISABLED_BY.
-#define DC_STR_PROTECTION_DISABLED        89
-
 /// "Reply"
 ///
 /// Used in summaries.
@@ -6611,7 +7009,7 @@ void dc_event_unref(dc_event_t* event);
 
 /// "You changed your email address from %1$s to %2$s.
 /// If you now send a message to a group, contacts there will automatically
-/// replace the old with your new address.\n\nIt's highly advised to set up 
+/// replace the old with your new address.\n\n It's highly advised to set up 
 /// your old email provider to forward all emails to your new email address. 
 /// Otherwise you might miss messages of contacts who did not get your new 
 /// address yet." + the link to the AEAP blog post
@@ -6842,25 +7240,25 @@ void dc_event_unref(dc_event_t* event);
 /// `%2$s` will be replaced by name and address of the contact.
 #define DC_STR_EPHEMERAL_TIMER_WEEKS_BY_OTHER 157
 
-/// "You enabled chat protection."
+/// "Scan to set up second device for %1$s"
 ///
-/// Used in status messages.
-#define DC_STR_PROTECTION_ENABLED_BY_YOU 158
+/// `%1$s` will be replaced by name and address of the account.
+#define DC_STR_BACKUP_TRANSFER_QR 162
 
-/// "Chat protection enabled by %1$s."
+/// "Account transferred to your second device."
 ///
-/// `%1$s` will be replaced by name and address of the contact.
-///
-/// Used in status messages.
-#define DC_STR_PROTECTION_ENABLED_BY_OTHER 159
+/// Used as a device message after a successful backup transfer.
+#define DC_STR_BACKUP_TRANSFER_MSG_BODY 163
 
-/// "You disabled chat protection."
-#define DC_STR_PROTECTION_DISABLED_BY_YOU 160
-
-/// "Chat protection disabled by %1$s."
+/// "Messages are guaranteed to be end-to-end encrypted from now on."
 ///
-/// `%1$s` will be replaced by name and address of the contact.
-#define DC_STR_PROTECTION_DISABLED_BY_OTHER 161
+/// Used in info messages.
+#define DC_STR_CHAT_PROTECTION_ENABLED 170
+
+/// "%1$s sent a message from another device."
+///
+/// Used in info messages.
+#define DC_STR_CHAT_PROTECTION_DISABLED 171
 
 /**
  * @}

deltachat-ffi/src/lot.rs

@@ -14,6 +14,8 @@ 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),
@@ -22,20 +24,15 @@ pub enum Lot {
 }
 
 #[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Default, 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 {
@@ -52,6 +49,7 @@ 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),
@@ -103,6 +101,7 @@ 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,
@@ -127,6 +126,7 @@ 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 +151,9 @@ impl Lot {
 }
 
 #[repr(u32)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
 pub enum LotState {
-    // Default
+    #[default]
     Undefined = 0,
 
     // Qr States
@@ -175,6 +175,8 @@ pub enum LotState {
     /// text1=domain
     QrAccount = 250,
 
+    QrBackup = 251,
+
     /// text1=domain, text2=instance pattern
     QrWebrtcInstance = 260,
 
@@ -215,12 +217,6 @@ 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-jsonrpc/.gitignore

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

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.107.0"
+version = "1.127.2"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
@@ -15,26 +15,29 @@ required-features = ["webserver"]
 anyhow = "1"
 deltachat = { path = ".." }
 num-traits = "0.2"
+schemars = "0.8.13"
 serde = { version = "1.0", features = ["derive"] }
-tempfile = "3.3.0"
+tempfile = "3.8.0"
 log = "0.4"
-async-channel = { version = "1.8.0" }
-futures = { version = "0.3.25" }
-serde_json = "1.0.91"
-yerpc = { version = "^0.3.1", features = ["anyhow_expose"] }
-typescript-type-def = { version = "0.5.5", features = ["json_value"] }
-tokio = { version = "1.23.1" }
-sanitize-filename = "0.4"
-walkdir = "2.3.2"
+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"
 
 # optional dependencies
-axum = { version = "0.6.1", optional = true, features = ["ws"] }
+axum = { version = "0.6.20", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.23.1", features = ["full", "rt-multi-thread"] }
+tokio = { version = "1.33.0", features = ["full", "rt-multi-thread"] }
 
 
 [features]
-default = []
-webserver = ["env_logger", "axum", "tokio/full", "yerpc/support-axum"]
+default = ["vendored"]
+webserver = ["dep:env_logger", "dep:axum", "tokio/full", "yerpc/support-axum"]
+vendored = ["deltachat/vendored"]

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 targetting 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 targeting 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 `DCC_NEW_TMP_EMAIL` environment variable to your mailadm token before running the tests.
+Then, set the `CHATMAIL_DOMAIN` environment variable to your testing email server domain.
 
 ```
-DCC_NEW_TMP_EMAIL=https://testrun.org/new_email?t=yourtoken npm run test
+CHATMAIL_DOMAIN=chat.example.org npm run test
 ```
 
 #### Test Coverage

deltachat-jsonrpc/src/api.rs

@@ -4,46 +4,50 @@ 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, 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 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, sync::RwLock};
+use tokio::fs;
+use tokio::sync::{watch, Mutex, RwLock};
 use walkdir::WalkDir;
 use yerpc::rpc;
 
-pub mod events;
 pub mod types;
 
 use num_traits::FromPrimitive;
 use types::account::Account;
 use types::chat::FullChat;
-use types::chat_list::ChatListEntry;
 use types::contact::ContactObject;
-use types::message::MessageObject;
+use types::events::Event;
+use types::http::HttpResponse;
+use types::message::{MessageData, MessageObject, MessageReadReceipt};
 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,
@@ -54,21 +58,45 @@ use self::types::{
 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,
+        }
+    }
+}
+
 #[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 }
+        CommandApi {
+            accounts,
+            states: Arc::new(Mutex::new(BTreeMap::new())),
+        }
     }
 
     async fn get_context(&self, id: u32) -> Result<deltachat::context::Context> {
@@ -80,24 +108,71 @@ 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
     // ---------------------------------------------
 
-    /// Check if an email address is valid.
+    /// Checks if an email address is valid.
     async fn check_email_validity(&self, email: String) -> bool {
         may_be_valid_addr(&email)
     }
 
-    /// Get general system info.
+    /// Returns 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
     // ---------------------------------------------
@@ -107,7 +182,13 @@ impl CommandApi {
     }
 
     async fn remove_account(&self, account_id: u32) -> Result<()> {
-        self.accounts.write().await.remove_account(account_id).await
+        self.accounts
+            .write()
+            .await
+            .remove_account(account_id)
+            .await?;
+        self.states.lock().await.remove(&account_id);
+        Ok(())
     }
 
     async fn get_all_account_ids(&self) -> Vec<u32> {
@@ -133,18 +214,18 @@ 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.read().await.start_io().await;
         Ok(())
     }
 
+    /// Stops background tasks for all accounts.
     async fn stop_io_for_all_accounts(&self) -> Result<()> {
         self.accounts.read().await.stop_io().await;
         Ok(())
@@ -154,14 +235,16 @@ impl CommandApi {
     // Methods that work on individual accounts
     // ---------------------------------------------
 
-    async fn start_io(&self, id: u32) -> Result<()> {
-        let ctx = self.get_context(id).await?;
+    /// Starts background tasks for a single account.
+    async fn start_io(&self, account_id: u32) -> Result<()> {
+        let ctx = self.get_context(account_id).await?;
         ctx.start_io().await;
         Ok(())
     }
 
-    async fn stop_io(&self, id: u32) -> Result<()> {
-        let ctx = self.get_context(id).await?;
+    /// Stops background tasks for a single account.
+    async fn stop_io(&self, account_id: u32) -> Result<()> {
+        let ctx = self.get_context(account_id).await?;
         ctx.stop_io().await;
         Ok(())
     }
@@ -228,11 +311,13 @@ 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,
@@ -242,7 +327,7 @@ impl CommandApi {
         for (key, value) in config.into_iter() {
             set_config(&ctx, &key, value.as_deref())
                 .await
-                .with_context(|| format!("Can't set {} to {:?}", key, value))?;
+                .with_context(|| format!("Can't set {key} to {value:?}"))?;
         }
         Ok(())
     }
@@ -264,6 +349,7 @@ 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
@@ -381,6 +467,49 @@ 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
@@ -424,7 +553,7 @@ impl CommandApi {
         list_flags: Option<u32>,
         query_string: Option<String>,
         query_contact_id: Option<u32>,
-    ) -> Result<Vec<ChatListEntry>> {
+    ) -> Result<Vec<u32>> {
         let ctx = self.get_context(account_id).await?;
         let list = Chatlist::try_load(
             &ctx,
@@ -433,33 +562,44 @@ impl CommandApi {
             query_contact_id.map(ContactId::new),
         )
         .await?;
-        let mut l: Vec<ChatListEntry> = Vec::with_capacity(list.len());
+        let mut l: Vec<u32> = Vec::with_capacity(list.len());
         for i in 0..list.len() {
-            l.push(ChatListEntry(
-                list.get_chat_id(i)?.to_u32(),
-                list.get_msg_id(i)?.unwrap_or_default().to_u32(),
-            ));
+            l.push(list.get_chat_id(i)?.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<ChatListEntry>,
+        entries: Vec<u32>,
     ) -> 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.0,
+                entry,
                 match get_chat_list_item_by_id(&ctx, entry).await {
                     Ok(res) => res,
                     Err(err) => ChatListItemFetchResult::Error {
-                        id: entry.0,
-                        error: format!("{:?}", err),
+                        id: entry,
+                        error: format!("{err:#}"),
                     },
                 },
             );
@@ -675,24 +815,12 @@ impl CommandApi {
     /// Create a new broadcast list.
     ///
     /// Broadcast lists are similar to groups on the sending device,
-    /// however, recipients get the messages in normal one-to-one chats
-    /// and will not be aware of other members.
+    /// however, recipients get the messages in a read-only chat
+    /// and will see who the other members are.
     ///
-    /// 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.
+    /// 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.
     async fn create_broadcast_list(&self, account_id: u32) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
         chat::create_broadcast_list(&ctx)
@@ -777,7 +905,7 @@ impl CommandApi {
     ) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
         let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(Some(text));
+        msg.set_text(text);
         let message_id =
             deltachat::chat::add_device_msg(&ctx, Some(&label), Some(&mut msg)).await?;
         Ok(message_id.to_u32())
@@ -803,7 +931,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), 0).await?;
+        let messages = get_chat_msgs(&ctx, ChatId::new(chat_id)).await?;
         let mut first_unread_message_id = None;
         for item in messages.into_iter().rev() {
             if let ChatItem::Message { msg_id } = item {
@@ -872,15 +1000,34 @@ 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, flags: u32) -> Result<Vec<u32>> {
+    async fn get_message_ids(
+        &self,
+        account_id: u32,
+        chat_id: u32,
+        info_only: bool,
+        add_daymarker: bool,
+    ) -> Result<Vec<u32>> {
         let ctx = self.get_context(account_id).await?;
-        let msg = get_chat_msgs(&ctx, ChatId::new(chat_id), flags).await?;
+        let msg = get_chat_msgs_ex(
+            &ctx,
+            ChatId::new(chat_id),
+            MessageListOptions {
+                info_only,
+                add_daymarker,
+            },
+        )
+        .await?;
         Ok(msg
             .iter()
             .map(|chat_item| -> u32 {
@@ -896,10 +1043,19 @@ impl CommandApi {
         &self,
         account_id: u32,
         chat_id: u32,
-        flags: u32,
+        info_only: bool,
+        add_daymarker: bool,
     ) -> Result<Vec<JSONRPCMessageListItem>> {
         let ctx = self.get_context(account_id).await?;
-        let msg = get_chat_msgs(&ctx, ChatId::new(chat_id), flags).await?;
+        let msg = get_chat_msgs_ex(
+            &ctx,
+            ChatId::new(chat_id),
+            MessageListOptions {
+                info_only,
+                add_daymarker,
+            },
+        )
+        .await?;
         Ok(msg
             .iter()
             .map(|chat_item| (*chat_item).into())
@@ -916,17 +1072,27 @@ 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, MessageObject>> {
+    ) -> Result<HashMap<u32, MessageLoadResult>> {
         let ctx = self.get_context(account_id).await?;
-        let mut messages: HashMap<u32, MessageObject> = HashMap::new();
+        let mut messages: HashMap<u32, MessageLoadResult> = HashMap::new();
         for message_id in message_ids {
+            let message_result = MessageObject::from_message_id(&ctx, message_id).await;
             messages.insert(
                 message_id,
-                MessageObject::from_message_id(&ctx, message_id).await?,
+                match message_result {
+                    Ok(message) => MessageLoadResult::Message(message),
+                    Err(error) => MessageLoadResult::LoadingError {
+                        error: format!("{error:#}"),
+                    },
+                },
             );
         }
         Ok(messages)
@@ -957,7 +1123,35 @@ 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?;
-        get_msg_info(&ctx, MsgId::new(message_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)
     }
 
     /// Asks the core to start downloading a message fully.
@@ -977,17 +1171,17 @@ impl CommandApi {
     }
 
     /// Search messages containing the given query string.
-    /// Searching can be done globally (chat_id=0) or in a specified chat only (chat_id set).
+    /// Searching can be done globally (chat_id=None) or in a specified chat only (chat_id set).
     ///
-    /// Global chat results are typically displayed using dc_msg_get_summary(), chat
-    /// search results may just hilite the corresponding messages and present a
+    /// Global search results are typically displayed using dc_msg_get_summary(), chat
+    /// search results may just highlight the corresponding messages and present a
     /// prev/next button.
     ///
-    /// 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.
+    /// 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.
     async fn search_messages(
         &self,
         account_id: u32,
@@ -1160,7 +1354,7 @@ impl CommandApi {
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
         let contact_id = ContactId::new(contact_id);
-        let contact = Contact::load_from_db(&ctx, contact_id).await?;
+        let contact = Contact::get_by_id(&ctx, contact_id).await?;
         let addr = contact.get_addr();
         Contact::create(&ctx, &name, addr).await?;
         Ok(())
@@ -1234,6 +1428,10 @@ 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,
@@ -1284,16 +1482,13 @@ impl CommandApi {
         passphrase: Option<String>,
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
-        ctx.stop_io().await;
-        let result = imex::imex(
+        imex::imex(
             &ctx,
             imex::ImexMode::ExportBackup,
             destination.as_ref(),
             passphrase,
         )
-        .await;
-        ctx.start_io().await;
-        result
+        .await
     }
 
     async fn import_backup(
@@ -1312,6 +1507,75 @@ 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
     // ---------------------------------------------
@@ -1422,6 +1686,32 @@ 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,
@@ -1439,6 +1729,20 @@ 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,
@@ -1450,6 +1754,9 @@ 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())
     }
@@ -1471,6 +1778,70 @@ 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
@@ -1519,7 +1890,7 @@ impl CommandApi {
             .context("path conversion to string failed")
     }
 
-    /// save a sticker to a collection/folder in the account's sticker folder
+    /// Saves a sticker to a collection/folder in the account's sticker folder.
     async fn misc_save_sticker(
         &self,
         account_id: u32,
@@ -1612,7 +1983,7 @@ impl CommandApi {
         let ctx = self.get_context(account_id).await?;
 
         let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(Some(text));
+        msg.set_text(text);
 
         let message_id = deltachat::chat::send_msg(&ctx, ChatId::new(chat_id), &mut msg).await?;
         Ok(message_id.to_u32())
@@ -1635,9 +2006,7 @@ impl CommandApi {
         } else {
             Viewtype::Text
         });
-        if text.is_some() {
-            message.set_text(text);
-        }
+        message.set_text(text.unwrap_or_default());
         if let Some(file) = file {
             message.set_file(file, None);
         }
@@ -1674,16 +2043,20 @@ 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(if file.is_some() {
-            Viewtype::File
-        } else {
-            Viewtype::Text
-        });
-        if text.is_some() {
-            draft.set_text(text);
-        }
+        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());
         if let Some(file) = file {
             draft.set_file(file, None);
         }
@@ -1702,6 +2075,23 @@ 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)
@@ -1714,7 +2104,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?;
@@ -1736,7 +2126,19 @@ 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)]
-#[serde(tag = "type")]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[serde(tag = "kind")]
 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::{anyhow, bail, Result};
+use anyhow::{bail, Context as _, Result};
 use deltachat::chat::{self, get_chat_contacts, ChatVisibility};
 use deltachat::chat::{Chat, ChatId};
 use deltachat::constants::Chattype;
@@ -13,7 +13,7 @@ use typescript_type_def::TypeDef;
 use super::color_int_to_hex_string;
 use super::contact::ContactObject;
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct FullChat {
     id: u32,
@@ -31,6 +31,7 @@ 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,
@@ -53,7 +54,9 @@ impl FullChat {
             contacts.push(
                 ContactObject::try_from_dc_contact(
                     context,
-                    Contact::load_from_db(context, *contact_id).await?,
+                    Contact::get_by_id(context, *contact_id)
+                        .await
+                        .context("failed to load contact")?,
                 )
                 .await?,
             )
@@ -72,8 +75,9 @@ impl FullChat {
 
         let was_seen_recently = if chat.get_type() == Chattype::Single {
             match contact_ids.get(0) {
-                Some(contact) => Contact::load_from_db(context, *contact)
-                    .await?
+                Some(contact) => Contact::get_by_id(context, *contact)
+                    .await
+                    .context("failed to load contact for was_seen_recently")?
                     .was_seen_recently(),
                 None => false,
             }
@@ -89,10 +93,7 @@ impl FullChat {
             is_protected: chat.is_protected(),
             profile_image, //BLOBS ?
             archived: chat.get_visibility() == chat::ChatVisibility::Archived,
-            chat_type: chat
-                .get_type()
-                .to_u32()
-                .ok_or_else(|| anyhow!("unknown chat type id"))?, // TODO get rid of this unwrap?
+            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
             is_unpromoted: chat.is_unpromoted(),
             is_self_talk: chat.is_self_talk(),
             contacts,
@@ -100,6 +101,7 @@ 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(),
@@ -121,7 +123,7 @@ impl FullChat {
 /// - can_send
 ///
 /// used when you only need the basic metadata of a chat like type, name, profile picture
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct BasicChat {
     id: u32,
@@ -134,6 +136,7 @@ pub struct BasicChat {
     is_self_talk: bool,
     color: String,
     is_contact_request: bool,
+    is_protection_broken: bool,
     is_device_chat: bool,
     is_muted: bool,
 }
@@ -155,25 +158,24 @@ impl BasicChat {
             is_protected: chat.is_protected(),
             profile_image, //BLOBS ?
             archived: chat.get_visibility() == chat::ChatVisibility::Archived,
-            chat_type: chat
-                .get_type()
-                .to_u32()
-                .ok_or_else(|| anyhow!("unknown chat type id"))?, // TODO get rid of this unwrap?
+            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
             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)]
+#[derive(Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
+#[serde(tag = "kind")]
 pub enum MuteDuration {
     NotMuted,
     Forever,
-    Until(i64),
+    Until { duration: i64 },
 }
 
 impl MuteDuration {
@@ -181,20 +183,20 @@ impl MuteDuration {
         match self {
             MuteDuration::NotMuted => Ok(chat::MuteDuration::NotMuted),
             MuteDuration::Forever => Ok(chat::MuteDuration::Forever),
-            MuteDuration::Until(n) => {
-                if n <= 0 {
+            MuteDuration::Until { duration } => {
+                if duration <= 0 {
                     bail!("failed to read mute duration")
                 }
 
                 Ok(SystemTime::now()
-                    .checked_add(Duration::from_secs(n as u64))
+                    .checked_add(Duration::from_secs(duration as u64))
                     .map_or(chat::MuteDuration::Forever, chat::MuteDuration::Until))
             }
         }
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, TypeDef)]
+#[derive(Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "ChatVisibility")]
 pub enum JSONRPCChatVisibility {
     Normal,

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

@@ -1,25 +1,21 @@
-use anyhow::Result;
+use anyhow::{Context, Result};
+use deltachat::chat::{Chat, ChatId};
+use deltachat::chatlist::get_last_message_for_chat;
 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::{Deserialize, Serialize};
+use serde::Serialize;
 use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
+use super::message::MessageViewtype;
 
-#[derive(Deserialize, Serialize, TypeDef)]
-pub struct ChatListEntry(pub u32, pub u32);
-
-#[derive(Serialize, TypeDef)]
-#[serde(tag = "type")]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[serde(tag = "kind")]
 pub enum ChatListItemFetchResult {
     #[serde(rename_all = "camelCase")]
     ChatListItem {
@@ -31,6 +27,8 @@ 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,
@@ -47,6 +45,8 @@ 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>,
     },
     #[serde(rename_all = "camelCase")]
     ArchiveLink { fresh_message_counter: usize },
@@ -56,14 +56,9 @@ pub enum ChatListItemFetchResult {
 
 pub(crate) async fn get_chat_list_item_by_id(
     ctx: &deltachat::context::Context,
-    entry: &ChatListEntry,
+    entry: u32,
 ) -> Result<ChatListItemFetchResult> {
-    let chat_id = ChatId::new(entry.0);
-    let last_msgid = match entry.1 {
-        0 => None,
-        _ => Some(MsgId::new(entry.1)),
-    };
-
+    let chat_id = ChatId::new(entry);
     let fresh_message_counter = chat_id.get_fresh_msg_cnt(ctx).await?;
 
     if chat_id.is_archived_link() {
@@ -72,12 +67,18 @@ pub(crate) async fn get_chat_list_item_by_id(
         });
     }
 
-    let chat = Chat::load_from_db(ctx, chat_id).await?;
-    let summary = Chatlist::get_summary2(ctx, chat_id, last_msgid, Some(&chat)).await?;
+    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 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
@@ -85,12 +86,15 @@ 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 = match last_msgid {
+    let (last_updated, message_type) = 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_timestamp() * 1000),
+                Some(last_message.get_viewtype().into()),
+            )
         }
-        None => None,
+        None => (None, None),
     };
 
     let chat_contacts = get_chat_contacts(ctx, chat_id).await?;
@@ -100,8 +104,9 @@ 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::load_from_db(ctx, *contact)
-                .await?
+            Some(contact) => Contact::get_by_id(ctx, *contact)
+                .await
+                .context("contact")?
                 .was_seen_recently(),
             None => false,
         };
@@ -124,6 +129,7 @@ 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,
@@ -138,5 +144,7 @@ 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)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Contact", rename_all = "camelCase")]
 pub struct ContactObject {
     address: String,

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

@@ -1,19 +1,29 @@
-use deltachat::{Event, EventType};
+use deltachat::{Event as CoreEvent, EventType as CoreEventType};
 use serde::Serialize;
-use serde_json::{json, Value};
 use typescript_type_def::TypeDef;
 
-pub fn event_to_json_rpc_notification(event: Event) -> Value {
-    let id: JSONRPCEventType = event.typ.into();
-    json!({
-        "event": id,
-        "contextId": event.id,
-    })
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct Event {
+    /// Event payload.
+    event: EventType,
+
+    /// Account ID.
+    context_id: u32,
 }
 
-#[derive(Serialize, TypeDef)]
-#[serde(tag = "type", rename = "Event")]
-pub enum JSONRPCEventType {
+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 {
     /// 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
@@ -47,6 +57,9 @@ pub enum JSONRPCEventType {
         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,
@@ -161,6 +174,13 @@ pub enum JSONRPCEventType {
         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()
@@ -283,26 +303,27 @@ pub enum JSONRPCEventType {
     },
 }
 
-impl From<EventType> for JSONRPCEventType {
-    fn from(event: EventType) -> Self {
-        use JSONRPCEventType::*;
+impl From<CoreEventType> for EventType {
+    fn from(event: CoreEventType) -> Self {
+        use EventType::*;
         match event {
-            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 {
+            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 {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            EventType::ReactionsChanged {
+            CoreEventType::ReactionsChanged {
                 chat_id,
                 msg_id,
                 contact_id,
@@ -311,92 +332,80 @@ impl From<EventType> for JSONRPCEventType {
                 msg_id: msg_id.to_u32(),
                 contact_id: contact_id.to_u32(),
             },
-            EventType::IncomingMsg { chat_id, msg_id } => IncomingMsg {
+            CoreEventType::IncomingMsg { chat_id, msg_id } => IncomingMsg {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            EventType::IncomingMsgBunch { msg_ids } => IncomingMsgBunch {
+            CoreEventType::IncomingMsgBunch { msg_ids } => IncomingMsgBunch {
                 msg_ids: msg_ids.into_iter().map(|id| id.to_u32()).collect(),
             },
-            EventType::MsgsNoticed(chat_id) => MsgsNoticed {
+            CoreEventType::MsgsNoticed(chat_id) => MsgsNoticed {
                 chat_id: chat_id.to_u32(),
             },
-            EventType::MsgDelivered { chat_id, msg_id } => MsgDelivered {
+            CoreEventType::MsgDelivered { chat_id, msg_id } => MsgDelivered {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            EventType::MsgFailed { chat_id, msg_id } => MsgFailed {
+            CoreEventType::MsgFailed { chat_id, msg_id } => MsgFailed {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            EventType::MsgRead { chat_id, msg_id } => MsgRead {
+            CoreEventType::MsgRead { chat_id, msg_id } => MsgRead {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            EventType::ChatModified(chat_id) => ChatModified {
+            CoreEventType::MsgDeleted { chat_id, msg_id } => MsgDeleted {
+                chat_id: chat_id.to_u32(),
+                msg_id: msg_id.to_u32(),
+            },
+            CoreEventType::ChatModified(chat_id) => ChatModified {
                 chat_id: chat_id.to_u32(),
             },
-            EventType::ChatEphemeralTimerModified { chat_id, timer } => {
+            CoreEventType::ChatEphemeralTimerModified { chat_id, timer } => {
                 ChatEphemeralTimerModified {
                     chat_id: chat_id.to_u32(),
                     timer: timer.to_u32(),
                 }
             }
-            EventType::ContactsChanged(contact) => ContactsChanged {
+            CoreEventType::ContactsChanged(contact) => ContactsChanged {
                 contact_id: contact.map(|c| c.to_u32()),
             },
-            EventType::LocationChanged(contact) => LocationChanged {
+            CoreEventType::LocationChanged(contact) => LocationChanged {
                 contact_id: contact.map(|c| c.to_u32()),
             },
-            EventType::ConfigureProgress { progress, comment } => {
+            CoreEventType::ConfigureProgress { progress, comment } => {
                 ConfigureProgress { progress, comment }
             }
-            EventType::ImexProgress(progress) => ImexProgress { progress },
-            EventType::ImexFileWritten(path) => ImexFileWritten {
+            CoreEventType::ImexProgress(progress) => ImexProgress { progress },
+            CoreEventType::ImexFileWritten(path) => ImexFileWritten {
                 path: path.to_str().unwrap_or_default().to_owned(),
             },
-            EventType::SecurejoinInviterProgress {
+            CoreEventType::SecurejoinInviterProgress {
                 contact_id,
                 progress,
             } => SecurejoinInviterProgress {
                 contact_id: contact_id.to_u32(),
                 progress,
             },
-            EventType::SecurejoinJoinerProgress {
+            CoreEventType::SecurejoinJoinerProgress {
                 contact_id,
                 progress,
             } => SecurejoinJoinerProgress {
                 contact_id: contact_id.to_u32(),
                 progress,
             },
-            EventType::ConnectivityChanged => ConnectivityChanged,
-            EventType::SelfavatarChanged => SelfavatarChanged,
-            EventType::WebxdcStatusUpdate {
+            CoreEventType::ConnectivityChanged => ConnectivityChanged,
+            CoreEventType::SelfavatarChanged => SelfavatarChanged,
+            CoreEventType::WebxdcStatusUpdate {
                 msg_id,
                 status_update_serial,
             } => WebxdcStatusUpdate {
                 msg_id: msg_id.to_u32(),
                 status_update_serial: status_update_serial.to_u32(),
             },
-            EventType::WebxdcInstanceDeleted { msg_id } => WebxdcInstanceDeleted {
+            CoreEventType::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/types/http.rs

@@ -0,0 +1,29 @@
+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)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[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::{anyhow, Result};
+use anyhow::{Context as _, Result};
 use deltachat::chat::Chat;
 use deltachat::chat::ChatItem;
-use deltachat::constants::Chattype;
+use deltachat::chat::ChatVisibility;
 use deltachat::contact::Contact;
 use deltachat::context::Context;
 use deltachat::download;
@@ -10,8 +10,7 @@ use deltachat::message::MsgId;
 use deltachat::message::Viewtype;
 use deltachat::reaction::get_msg_reactions;
 use num_traits::cast::ToPrimitive;
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
@@ -19,7 +18,14 @@ use super::contact::ContactObject;
 use super::reactions::JSONRPCReactions;
 use super::webxdc::WebxdcMessageInfo;
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[serde(rename_all = "camelCase", tag = "kind")]
+pub enum MessageLoadResult {
+    Message(MessageObject),
+    LoadingError { error: String },
+}
+
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Message", rename_all = "camelCase")]
 pub struct MessageObject {
     id: u32,
@@ -28,7 +34,7 @@ pub struct MessageObject {
     quote: Option<MessageQuote>,
     parent_id: Option<u32>,
 
-    text: Option<String>,
+    text: String,
     has_location: bool,
     has_html: bool,
     view_type: MessageViewtype,
@@ -48,6 +54,10 @@ 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,
 
@@ -75,7 +85,7 @@ pub struct MessageObject {
     reactions: Option<JSONRPCReactions>,
 }
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(tag = "kind")]
 enum MessageQuote {
     JustText {
@@ -103,8 +113,12 @@ 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::load_from_db(context, message.get_from_id()).await?;
-        let sender = ContactObject::try_from_dc_contact(context, sender_contact).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 override_sender_name = message.get_override_sender_name();
 
@@ -121,7 +135,9 @@ impl MessageObject {
         let quote = if let Some(quoted_text) = message.quoted_text() {
             match message.quoted_message(context).await? {
                 Some(quote) => {
-                    let quote_author = Contact::load_from_db(context, quote.get_from_id()).await?;
+                    let quote_author = Contact::get_by_id(context, quote.get_from_id())
+                        .await
+                        .context("failed to load quote author contact")?;
                     Some(MessageQuote::WithMessage {
                         text: quoted_text,
                         message_id: quote.get_id().to_u32(),
@@ -149,7 +165,9 @@ impl MessageObject {
             None
         };
 
-        let reactions = get_msg_reactions(context, msg_id).await?;
+        let reactions = get_msg_reactions(context, msg_id)
+            .await
+            .context("failed to load message reactions")?;
         let reactions = if reactions.is_empty() {
             None
         } else {
@@ -169,7 +187,7 @@ impl MessageObject {
             state: message
                 .get_state()
                 .to_u32()
-                .ok_or_else(|| anyhow!("state conversion to number failed"))?,
+                .context("state conversion to number failed")?,
             error: message.error(),
 
             timestamp: message.get_timestamp(),
@@ -182,6 +200,7 @@ 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(),
@@ -191,7 +210,7 @@ impl MessageObject {
             videochat_type: match message.get_videochat_type() {
                 Some(vct) => Some(
                     vct.to_u32()
-                        .ok_or_else(|| anyhow!("state conversion to number failed"))?,
+                        .context("videochat type conversion to number failed")?,
                 ),
                 None => None,
             },
@@ -218,7 +237,7 @@ impl MessageObject {
     }
 }
 
-#[derive(Serialize, Deserialize, TypeDef)]
+#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Viewtype")]
 pub enum MessageViewtype {
     Unknown,
@@ -294,11 +313,12 @@ impl From<MessageViewtype> for Viewtype {
     }
 }
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 pub enum DownloadState {
     Done,
     Available,
     Failure,
+    Undecipherable,
     InProgress,
 }
 
@@ -308,12 +328,13 @@ 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)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 pub enum SystemMessageType {
     Unknown,
     GroupNameChanged,
@@ -368,7 +389,7 @@ impl From<deltachat::mimeparser::SystemMessage> for SystemMessageType {
     }
 }
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct MessageNotificationInfo {
     id: u32,
@@ -426,14 +447,22 @@ impl MessageNotificationInfo {
     }
 }
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[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,
-    chat_name: Option<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,
     message: String,
     timestamp: i64,
 }
@@ -442,30 +471,44 @@ 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::load_from_db(context, message.get_from_id()).await?;
+        let sender = Contact::get_by_id(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: sender.get_display_name().to_owned(),
+            author_name,
             author_color: color_int_to_hex_string(sender.get_color()),
-            chat_name: if chat.get_type() == Chattype::Single {
-                Some(chat.get_name().to_owned())
-            } else {
-                None
-            },
-            message: message.get_text().unwrap_or_default(),
+            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(),
             timestamp: message.get_timestamp(),
         })
     }
 }
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase", rename = "MessageListItem", tag = "kind")]
 pub enum JSONRPCMessageListItem {
     Message {
@@ -490,3 +533,90 @@ 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,6 +2,8 @@ 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;
@@ -10,7 +12,7 @@ pub mod reactions;
 pub mod webxdc;
 
 pub fn color_int_to_hex_string(color: u32) -> String {
-    format!("{:#08x}", color).replace("0x", "#")
+    format!("{color:#08x}").replace("0x", "#")
 }
 
 fn maybe_empty_string_to_option(string: String) -> Option<String> {

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

@@ -3,17 +3,20 @@ use num_traits::cast::ToPrimitive;
 use serde::Serialize;
 use typescript_type_def::TypeDef;
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[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 simlicity 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 simplicity 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)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Qr", rename_all = "camelCase")]
-#[serde(tag = "type")]
+#[serde(tag = "kind")]
 pub enum QrObject {
     AskVerifyContact {
         contact_id: u32,
@@ -32,6 +32,9 @@ pub enum QrObject {
     Account {
         domain: String,
     },
+    Backup {
+        ticket: String,
+    },
     WebrtcInstance {
         domain: String,
         instance_pattern: String,
@@ -126,6 +129,9 @@ 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,23 +1,37 @@
 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)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[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
-    reactions: BTreeMap<String, u32>,
+    /// Unique reactions and their count, sorted in descending order.
+    reactions: Vec<JSONRPCReaction>,
 }
 
 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);
@@ -30,18 +44,29 @@ impl From<Reactions> for JSONRPCReactions {
                 .map(|emoji| emoji.to_owned())
                 .collect();
             reactions_by_contact.insert(contact_id.to_u32(), emojis.clone());
-            for emoji in emojis {
-                if let Some(x) = unique_reactions.get_mut(&emoji) {
-                    *x += 1;
-                } else {
-                    unique_reactions.insert(emoji, 1);
-                }
-            }
+        }
+
+        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)
         }
 
         JSONRPCReactions {
             reactions_by_contact,
-            reactions: unique_reactions,
+            reactions: reactions_v,
         }
     }
 }

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)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "WebxdcMessageInfo", rename_all = "camelCase")]
 pub struct WebxdcMessageInfo {
     /// The name of the app.

deltachat-jsonrpc/src/lib.rs

@@ -1,5 +1,4 @@
 pub mod api;
-pub use api::events;
 pub use yerpc;
 
 #[cfg(test)]
@@ -14,10 +13,11 @@ mod tests {
     #[tokio::test(flavor = "multi_thread")]
     async fn basic_json_rpc_functionality() -> anyhow::Result<()> {
         let tmp_dir = TempDir::new().unwrap().path().into();
-        let accounts = Accounts::new(tmp_dir).await?;
+        let writable = true;
+        let accounts = Accounts::new(tmp_dir, writable).await?;
         let api = CommandApi::new(accounts);
 
-        let (sender, mut receiver) = unbounded::<String>();
+        let (sender, receiver) = unbounded::<String>();
 
         let (client, mut rx) = RpcClient::new();
         let session = RpcSession::new(client, api);
@@ -36,17 +36,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.next().await;
-            println!("{:?}", result);
-            assert_eq!(result, Some(response.to_owned()));
+            let result = receiver.recv().await?;
+            println!("{result:?}");
+            assert_eq!(result, 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.next().await;
-            println!("{:?}", result);
-            assert_eq!(result, Some(response.to_owned()));
+            let result = receiver.recv().await?;
+            println!("{result:?}");
+            assert_eq!(result, response.to_owned());
         }
 
         Ok(())
@@ -55,10 +55,11 @@ mod tests {
     #[tokio::test(flavor = "multi_thread")]
     async fn test_batch_set_config() -> anyhow::Result<()> {
         let tmp_dir = TempDir::new().unwrap().path().into();
-        let accounts = Accounts::new(tmp_dir).await?;
+        let writable = true;
+        let accounts = Accounts::new(tmp_dir, writable).await?;
         let api = CommandApi::new(accounts);
 
-        let (sender, mut receiver) = unbounded::<String>();
+        let (sender, receiver) = unbounded::<String>();
 
         let (client, mut rx) = RpcClient::new();
         let session = RpcSession::new(client, api);
@@ -77,15 +78,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.next().await;
-            assert_eq!(result, Some(response.to_owned()));
+            let result = receiver.recv().await?;
+            assert_eq!(result, 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.next().await;
-            assert_eq!(result, Some(response.to_owned()));
+            let result = receiver.recv().await?;
+            assert_eq!(result, response.to_owned());
         }
 
         Ok(())

deltachat-jsonrpc/src/webserver.rs

@@ -6,7 +6,6 @@ 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;
@@ -20,7 +19,8 @@ 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 accounts = Accounts::new(PathBuf::from(&path)).await.unwrap();
+    let writable = true;
+    let accounts = Accounts::new(PathBuf::from(&path), writable).await.unwrap();
     let state = CommandApi::new(accounts);
 
     let app = Router::new()
@@ -44,12 +44,5 @@ 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,3 +4,9 @@ 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.type === "Configured") {
+      if (account.kind === "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.type !== "Configured") {
+    if (info.kind !== "Configured") {
       return write($main, "Account is not configured");
     }
     write($main, `<h2>${info.addr!}</h2>`);
@@ -67,23 +67,22 @@ async function run() {
       null,
       null
     );
-    for (const [chatId, _messageId] of chats) {
-      const chat = await client.rpc.getFullChatById(
-        selectedAccount,
-        chatId
-      );
+    for (const chatId of chats) {
+      const chat = await client.rpc.getFullChatById(selectedAccount, chatId);
       write($main, `<h3>${chat.name}</h3>`);
       const messageIds = await client.rpc.getMessageIds(
         selectedAccount,
         chatId,
-        0
+        false,
+        false
       );
       const messages = await client.rpc.getMessages(
         selectedAccount,
         messageIds
       );
       for (const [_messageId, message] of Object.entries(messages)) {
-        write($main, `<p>${message.text}</p>`);
+        if (message.kind === "message") write($main, `<p>${message.text}</p>`);
+        else write($main, `<p>loading error: ${message.error}</p>`);
       }
     }
   }
@@ -93,9 +92,9 @@ async function run() {
       $side,
       `
         <p class="message">
-          [<strong>${event.type}</strong> on account ${accountId}]<br>
+          [<strong>${event.kind}</strong> on account ${accountId}]<br>
           <em>f1:</em> ${JSON.stringify(
-            Object.assign({}, event, { type: undefined })
+            Object.assign({}, event, { kind: undefined })
           )}
         </p>`
     );

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

@@ -3,24 +3,27 @@ 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 acccount 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 account 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,7 +3,7 @@
   "dependencies": {
     "@deltachat/tiny-emitter": "3.0.0",
     "isomorphic-ws": "^4.0.1",
-    "yerpc": "^0.3.3"
+    "yerpc": "^0.4.3"
   },
   "devDependencies": {
     "@types/chai": "^4.2.21",
@@ -14,7 +14,7 @@
     "c8": "^7.10.0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
-    "esbuild": "^0.14.11",
+    "esbuild": "^0.17.9",
     "http-server": "^14.1.1",
     "mocha": "^9.1.1",
     "node-fetch": "^2.6.1",
@@ -24,12 +24,19 @@
     "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": "run-s generate-bindings extract-constants build:tsc build:bundle build:cjs",
     "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",
@@ -38,8 +45,8 @@
     "example:start": "http-server .",
     "extract-constants": "node ./scripts/generate-constants.js",
     "generate-bindings": "cargo test",
-    "prettier:check": "prettier --check **.ts",
-    "prettier:fix": "prettier --write **.ts",
+    "prettier:check": "prettier --check .",
+    "prettier:fix": "prettier --write .",
     "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",
@@ -48,5 +55,5 @@
   },
   "type": "module",
   "types": "dist/deltachat.d.ts",
-  "version": "1.107.0"
-}
+  "version": "1.127.2"
+}

deltachat-jsonrpc/typescript/report_api_coverage.mjs

@@ -1,5 +1,5 @@
 import { readFileSync } from "fs";
-// only checks for the coverge of the api functions in bindings.ts for now
+// only checks for the coverage 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,34 +1,28 @@
 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 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"]]: (
+type Events = { ALL: (accountId: number, event: EventType) => void } & {
+  [Property in EventType["kind"]]: (
     accountId: number,
-    event: Extract<Event, { type: Property }>
+    event: Extract<EventType, { kind: Property }>
   ) => void;
 };
 
-type ContextEvents = { ALL: (event: Event) => void } & {
-  [Property in Event["type"]]: (
-    event: Extract<Event, { type: Property }>
+type ContextEvents = { ALL: (event: EventType) => void } & {
+  [Property in EventType["kind"]]: (
+    event: Extract<EventType, { kind: Property }>
   ) => void;
 };
 
-export type DcEvent = Event;
-export type DcEventType<T extends Event["type"]> = Extract<Event, { type: T }>;
+export type DcEvent = EventType;
+export type DcEventType<T extends EventType["kind"]> = Extract<
+  EventType,
+  { kind: T }
+>;
 
 export class BaseDeltaChat<
   Transport extends BaseTransport<any>
@@ -36,27 +30,34 @@ export class BaseDeltaChat<
   rpc: RawClient;
   account?: T.Account;
   private contextEmitters: { [key: number]: TinyEmitter<ContextEvents> } = {};
-  constructor(public transport: Transport) {
+
+  //@ts-ignore
+  private eventTask: Promise<void>;
+
+  constructor(public transport: Transport, startEventLoop: boolean) {
     super();
     this.rpc = new RawClient(this.transport);
-    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);
+    if (startEventLoop) {
+      this.eventTask = this.eventLoop();
+    }
+  }
 
-        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 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);
       }
-    });
+    }
   }
 
   async listAccounts(): Promise<T.Account[]> {
@@ -75,10 +76,12 @@ 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;
@@ -86,20 +89,24 @@ export class DeltaChat extends BaseDeltaChat<WebsocketTransport> {
     this.transport.close();
   }
   constructor(opts?: Opts | string) {
-    if (typeof opts === "string") opts = { url: opts };
-    if (opts) opts = { ...DEFAULT_OPTS, ...opts };
-    else opts = { ...DEFAULT_OPTS };
+    if (typeof opts === "string") {
+      opts = { ...DEFAULT_OPTS, url: opts };
+    } else if (opts) {
+      opts = { ...DEFAULT_OPTS, ...opts };
+    } else {
+      opts = { ...DEFAULT_OPTS };
+    }
     const transport = new WebsocketTransport(opts.url);
-    super(transport);
+    super(transport, opts.startEventLoop);
     this.opts = opts;
   }
 }
 
 export class StdioDeltaChat extends BaseDeltaChat<StdioTransport> {
   close() {}
-  constructor(input: any, output: any) {
+  constructor(input: any, output: any, startEventLoop: boolean) {
     const transport = new StdioTransport(input, output);
-    super(transport);
+    super(transport, startEventLoop);
   }
 }
 
@@ -120,7 +127,7 @@ export class StdioTransport extends BaseTransport {
     });
   }
 
-  _send(message: RPC.Message): void {
+  _send(message: any): void {
     const serialized = JSON.stringify(message);
     this.input.write(serialized + "\n");
   }

deltachat-jsonrpc/typescript/src/lib.ts

@@ -1,6 +1,5 @@
 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,10 +4,7 @@ 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;
@@ -15,9 +12,9 @@ describe("basic tests", () => {
 
   before(async () => {
     serverHandle = await startServer();
-    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout)
+    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout, true);
     // dc.on("ALL", (event) => {
-      //console.log("event", event);
+    //console.log("event", event);
     // });
   });
 
@@ -56,7 +53,7 @@ describe("basic tests", () => {
     ]);
   });
 
-  describe("account managment", () => {
+  describe("account management", () => {
     it("should create account", async () => {
       const res = await dc.rpc.addAccount();
       assert((await dc.rpc.getAllAccountIds()).length === 1);
@@ -76,7 +73,7 @@ describe("basic tests", () => {
     });
   });
 
-  describe("contact managment", function () {
+  describe("contact management", function () {
     let accountId: number;
     before(async () => {
       accountId = await dc.rpc.addAccount();
@@ -106,38 +103,44 @@ describe("basic tests", () => {
       accountId = await dc.rpc.addAccount();
     });
 
-    it("set and retrive", async function () {
+    it("set and retrieve", 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 retrive ui.*", async function () {
+    it("set and retrieve 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 retrive (batch)", async function () {
+    it("set and retrieve (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 retrive ui.* (batch)", async function () {
+    it("set and retrieve 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 retrive mixed(ui and core) (batch)", async function () {
+    it("set and retrieve mixed(ui and core) (batch)", async function () {
       const config = {
         "ui.chat_bg": "color:yellow",
         "ui.enter_key_sends": "false",
@@ -145,7 +148,10 @@ 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

@@ -13,38 +13,38 @@ describe("online tests", function () {
 
   before(async function () {
     this.timeout(60000);
-    if (!process.env.DCC_NEW_TMP_EMAIL) {
+    if (!process.env.CHATMAIL_DOMAIN) {
       if (process.env.COVERAGE && !process.env.COVERAGE_OFFLINE) {
         console.error(
-          "CAN NOT RUN COVERAGE correctly: Missing DCC_NEW_TMP_EMAIL environment variable!\n\n",
+          "CAN NOT RUN COVERAGE correctly: Missing CHATMAIL_DOMAIN 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 DCC_NEW_TMP_EMAIL environment variable!, skip intergration tests"
+        "Missing CHATMAIL_DOMAIN environment variable!, skip integration tests"
       );
       this.skip();
     }
     serverHandle = await startServer();
-    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout);
+    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout, true);
 
-    dc.on("ALL", (contextId, { type }) => {
-      if (type !== "Info") console.log(contextId, type);
+    dc.on("ALL", (contextId, { kind }) => {
+      if (kind !== "Info") console.log(contextId, kind);
     });
 
-    account1 = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
+    account1 = createTempUser(process.env.CHATMAIL_DOMAIN);
     if (!account1 || !account1.email || !account1.password) {
       console.log(
-        "We didn't got back an account from the api, skip intergration tests"
+        "We didn't got back an account from the api, skip integration tests"
       );
       this.skip();
     }
 
-    account2 = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
+    account2 = createTempUser(process.env.CHATMAIL_DOMAIN);
     if (!account2 || !account2.email || !account2.password) {
       console.log(
-        "We didn't got back an account2 from the api, skip intergration tests"
+        "We didn't got back an account2 from the api, skip integration tests"
       );
       this.skip();
     }
@@ -74,7 +74,7 @@ describe("online tests", function () {
     accountsConfigured = true;
   });
 
-  it("send and recieve text message", async function () {
+  it("send and receive text message", async function () {
     if (!accountsConfigured) {
       this.skip();
     }
@@ -97,7 +97,8 @@ describe("online tests", function () {
     const messageList = await dc.rpc.getMessageIds(
       accountId2,
       chatIdOnAccountB,
-      0
+      false,
+      false
     );
 
     expect(messageList).have.length(1);
@@ -105,7 +106,7 @@ describe("online tests", function () {
     expect(message.text).equal("Hello");
   });
 
-  it("send and recieve text message roundtrip, encrypted on answer onwards", async function () {
+  it("send and receive text message roundtrip, encrypted on answer onwards", async function () {
     if (!accountsConfigured) {
       this.skip();
     }
@@ -133,7 +134,8 @@ describe("online tests", function () {
     const messageList = await dc.rpc.getMessageIds(
       accountId2,
       chatIdOnAccountB,
-      0
+      false,
+      false
     );
     const message = await dc.rpc.getMessage(
       accountId2,
@@ -146,11 +148,11 @@ describe("online tests", function () {
       waitForEvent(dc, "IncomingMsg", accountId1),
     ]);
     dc.rpc.miscSendTextMessage(accountId2, chatId, "super secret message");
-    // Check if answer arives at A and if it is encrypted
+    // Check if answer arrives at A and if it is encrypted
     await eventPromise2;
 
     const messageId = (
-      await dc.rpc.getMessageIds(accountId1, chatId, 0)
+      await dc.rpc.getMessageIds(accountId1, chatId, false, false)
     ).reverse()[0];
     const message2 = await dc.rpc.getMessage(accountId1, messageId);
     expect(message2.text).equal("super secret message");
@@ -175,12 +177,12 @@ describe("online tests", function () {
   });
 });
 
-async function waitForEvent<T extends DcEvent["type"]>(
+async function waitForEvent<T extends DcEvent["kind"]>(
   dc: DeltaChat,
   eventType: T,
   accountId: number,
   timeout: number = EVENT_TIMEOUT
-): Promise<Extract<DcEvent, { type: T }>> {
+): Promise<Extract<DcEvent, { kind: 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

@@ -57,15 +57,14 @@ export async function startServer(): Promise<RpcServerHandle> {
   };
 }
 
-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(); 
+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 };
 }
 
 function getTargetDir(): Promise<string> {
@@ -89,4 +88,3 @@ function getTargetDir(): Promise<string> {
     );
   });
 }
-

deltachat-repl/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "deltachat-repl"
+version = "1.127.2"
+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.29"
+rustyline = "12"
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
+
+[features]
+default = ["vendored"]
+vendored = ["deltachat/vendored"]

deltachat-repl/src/cmdline.rs

@@ -18,6 +18,7 @@ use deltachat::imex::*;
 use deltachat::location;
 use deltachat::log::LogExt;
 use deltachat::message::{self, Message, MessageState, MsgId, Viewtype};
+use deltachat::mimeparser::SystemMessage;
 use deltachat::peerstate::*;
 use deltachat::qr::*;
 use deltachat::reaction::send_reaction;
@@ -29,13 +30,13 @@ use tokio::fs;
 
 /// Reset database tables.
 /// Argument is a bitmask, executing single or multiple actions in one call.
-/// e.g. bitmask 7 triggers actions definded with bits 1, 2 and 4.
+/// e.g. bitmask 7 triggers actions defined with bits 1, 2 and 4.
 async fn reset_tables(context: &Context, bits: i32) {
-    println!("Resetting tables ({})...", bits);
+    println!("Resetting tables ({bits})...");
     if 0 != bits & 1 {
         context
             .sql()
-            .execute("DELETE FROM jobs;", paramsv![])
+            .execute("DELETE FROM jobs;", ())
             .await
             .unwrap();
         println!("(1) Jobs reset.");
@@ -43,7 +44,7 @@ async fn reset_tables(context: &Context, bits: i32) {
     if 0 != bits & 2 {
         context
             .sql()
-            .execute("DELETE FROM acpeerstates;", paramsv![])
+            .execute("DELETE FROM acpeerstates;", ())
             .await
             .unwrap();
         println!("(2) Peerstates reset.");
@@ -51,7 +52,7 @@ async fn reset_tables(context: &Context, bits: i32) {
     if 0 != bits & 4 {
         context
             .sql()
-            .execute("DELETE FROM keypairs;", paramsv![])
+            .execute("DELETE FROM keypairs;", ())
             .await
             .unwrap();
         println!("(4) Private keypairs reset.");
@@ -59,36 +60,36 @@ async fn reset_tables(context: &Context, bits: i32) {
     if 0 != bits & 8 {
         context
             .sql()
-            .execute("DELETE FROM contacts WHERE id>9;", paramsv![])
+            .execute("DELETE FROM contacts WHERE id>9;", ())
             .await
             .unwrap();
         context
             .sql()
-            .execute("DELETE FROM chats WHERE id>9;", paramsv![])
+            .execute("DELETE FROM chats WHERE id>9;", ())
             .await
             .unwrap();
         context
             .sql()
-            .execute("DELETE FROM chats_contacts;", paramsv![])
+            .execute("DELETE FROM chats_contacts;", ())
             .await
             .unwrap();
         context
             .sql()
-            .execute("DELETE FROM msgs WHERE id>9;", paramsv![])
+            .execute("DELETE FROM msgs WHERE id>9;", ())
             .await
             .unwrap();
         context
             .sql()
             .execute(
                 "DELETE FROM config WHERE keyname LIKE 'imap.%' OR keyname LIKE 'configured%';",
-                paramsv![],
+                (),
             )
             .await
             .unwrap();
         context.sql().config_cache().write().await.clear();
         context
             .sql()
-            .execute("DELETE FROM leftgrps;", paramsv![])
+            .execute("DELETE FROM leftgrps;", ())
             .await
             .unwrap();
         println!("(8) Rest but server config reset.");
@@ -101,7 +102,7 @@ async fn poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<
     let data = read_file(context, filename).await?;
 
     if let Err(err) = receive_imf(context, &data, false).await {
-        println!("receive_imf errored: {:?}", err);
+        println!("receive_imf errored: {err:?}");
     }
     Ok(())
 }
@@ -138,22 +139,21 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
         /* import a directory */
         let dir_name = std::path::Path::new(&real_spec);
         let dir = fs::read_dir(dir_name).await;
-        if dir.is_err() {
-            error!(context, "Import: Cannot open directory \"{}\".", &real_spec,);
-            return false;
-        } else {
-            let mut dir = dir.unwrap();
+        if let Ok(mut dir) = dir {
             while let Ok(Some(entry)) = dir.next_entry().await {
                 let name_f = entry.file_name();
                 let name = name_f.to_string_lossy();
                 if name.ends_with(".eml") {
                     let path_plus_name = format!("{}/{}", &real_spec, name);
-                    println!("Import: {}", path_plus_name);
+                    println!("Import: {path_plus_name}");
                     if poke_eml_file(context, path_plus_name).await.is_ok() {
                         read_cnt += 1
                     }
                 }
             }
+        } else {
+            error!(context, "Import: Cannot open directory \"{}\".", &real_spec);
+            return false;
         }
     }
     println!("Import: {} items read from \"{}\".", read_cnt, &real_spec);
@@ -168,7 +168,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
         .await
         .expect("invalid contact");
     let contact_name = if let Some(name) = msg.get_override_sender_name() {
-        format!("~{}", name)
+        format!("~{name}")
     } else {
         contact.get_display_name().to_string()
     };
@@ -187,6 +187,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
         DownloadState::Available => " [⬇ Download available]",
         DownloadState::InProgress => " [⬇ Download in progress...]️",
         DownloadState::Failure => " [⬇ Download failed]",
+        DownloadState::Undecipherable => " [⬇ Decryption failed]",
     };
 
     let temp2 = timestamp_to_str(msg.get_timestamp());
@@ -199,7 +200,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
         if msg.has_location() { "📍" } else { "" },
         &contact_name,
         contact_id,
-        msgtext.unwrap_or_default(),
+        msgtext,
         if msg.has_html() { "[HAS-HTML]️" } else { "" },
         if msg.get_from_id() == ContactId::SELF {
             ""
@@ -210,7 +211,17 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
         } else {
             "[FRESH]"
         },
-        if msg.is_info() { "[INFO]" } else { "" },
+        if msg.is_info() {
+            if msg.get_info_type() == SystemMessage::ChatProtectionEnabled {
+                "[INFO 🛡️]"
+            } else if msg.get_info_type() == SystemMessage::ChatProtectionDisabled {
+                "[INFO 🛡️❌]"
+            } else {
+                "[INFO]"
+            }
+        } else {
+            ""
+        },
         if msg.get_viewtype() == Viewtype::VideochatInvitation {
             format!(
                 "[VIDEOCHAT-INVITATION: {}, type={}]",
@@ -223,7 +234,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
                     "[WEBXDC: {}, icon={}, document={}, summary={}, source_code_url={}]",
                     info.name, info.icon, info.document, info.summary, info.source_code_url
                 ),
-                Err(err) => format!("[get_webxdc_info() failed: {}]", err),
+                Err(err) => format!("[get_webxdc_info() failed: {err}]"),
             }
         } else {
             "".to_string()
@@ -336,6 +347,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                  has-backup\n\
                  export-backup\n\
                  import-backup <backup-file>\n\
+                 send-backup\n\
+                 receive-backup <qr>\n\
                  export-keys\n\
                  import-keys\n\
                  export-setup\n\
@@ -393,8 +406,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                  unpin <chat-id>\n\
                  mute <chat-id> [<seconds>]\n\
                  unmute <chat-id>\n\
-                 protect <chat-id>\n\
-                 unprotect <chat-id>\n\
                  delchat <chat-id>\n\
                  accept <chat-id>\n\
                  decline <chat-id>\n\
@@ -435,10 +446,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             ),
         },
         "initiate-key-transfer" => match initiate_key_transfer(&context).await {
-            Ok(setup_code) => println!(
-                "Setup code for the transferred setup message: {}",
-                setup_code,
-            ),
+            Ok(setup_code) => {
+                println!("Setup code for the transferred setup message: {setup_code}",)
+            }
             Err(err) => bail!("Failed to generate setup code: {}", err),
         },
         "get-setupcodebegin" => {
@@ -487,6 +497,17 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             )
             .await?;
         }
+        "send-backup" => {
+            let provider = BackupProvider::prepare(&context).await?;
+            let qr = provider.qr();
+            println!("QR code: {}", format_backup(&qr)?);
+            provider.await?;
+        }
+        "receive-backup" => {
+            ensure!(!arg1.is_empty(), "Argument <qr> is missing.");
+            let qr = check_qr(&context, arg1).await?;
+            deltachat::imex::get_backup(&context, qr).await?;
+        }
         "export-keys" => {
             let dir = dirs::home_dir().unwrap_or_default();
             imex(&context, ImexMode::ExportSelfKeys, dir.as_ref(), None).await?;
@@ -528,7 +549,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             ensure!(!arg1.is_empty(), "Argument <key> missing.");
             let key = config::Config::from_str(arg1)?;
             let val = context.get_config(key).await;
-            println!("{}={:?}", key, val);
+            println!("{key}={val:?}");
         }
         "info" => {
             println!("{:#?}", context.get_info().await);
@@ -540,7 +561,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             match context.get_connectivity_html().await {
                 Ok(html) => {
                     fs::write(&file, html).await?;
-                    println!("Report written to: {:#?}", file);
+                    println!("Report written to: {file:#?}");
                 }
                 Err(err) => {
                     bail!("Failed to get connectivity html: {}", err);
@@ -551,7 +572,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             context.maybe_network().await;
         }
         "housekeeping" => {
-            sql::housekeeping(&context).await.ok_or_log(&context);
+            sql::housekeeping(&context).await.log_err(&context).ok();
         }
         "listchats" | "listarchived" | "chats" => {
             let listflags = if arg0 == "listarchived" {
@@ -613,7 +634,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                         "{}{}{} [{}]{}",
                         summary
                             .prefix
-                            .map_or_else(String::new, |prefix| format!("{}: ", prefix)),
+                            .map_or_else(String::new, |prefix| format!("{prefix}: ")),
                         summary.text,
                         statestr,
                         &timestr,
@@ -631,8 +652,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             if location::is_sending_locations_to_chat(&context, None).await? {
                 println!("Location streaming enabled.");
             }
-            println!("{} chats", cnt);
-            println!("{:?} to create this list", time_needed);
+            println!("{cnt} chats");
+            println!("{time_needed:?} to create this list");
         }
         "chat" => {
             if sel_chat.is_none() && arg1.is_empty() {
@@ -640,7 +661,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             }
             if !arg1.is_empty() {
                 let id = ChatId::new(arg1.parse()?);
-                println!("Selecting chat {}", id);
+                println!("Selecting chat {id}");
                 sel_chat = Some(Chat::load_from_db(&context, id).await?);
                 *chat_id = id;
             }
@@ -649,8 +670,15 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let sel_chat = sel_chat.as_ref().unwrap();
 
             let time_start = std::time::SystemTime::now();
-            let msglist =
-                chat::get_chat_msgs(&context, sel_chat.get_id(), DC_GCM_ADDDAYMARKER).await?;
+            let msglist = chat::get_chat_msgs_ex(
+                &context,
+                sel_chat.get_id(),
+                chat::MessageListOptions {
+                    info_only: false,
+                    add_daymarker: true,
+                },
+            )
+            .await?;
             let time_needed = time_start.elapsed().unwrap_or_default();
 
             let msglist: Vec<MsgId> = msglist
@@ -686,7 +714,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 },
                 match sel_chat.get_profile_image(&context).await? {
                     Some(icon) => match icon.to_str() {
-                        Some(icon) => format!(" Icon: {}", icon),
+                        Some(icon) => format!(" Icon: {icon}"),
                         _ => " Icon: Err".to_string(),
                     },
                     _ => "".to_string(),
@@ -712,8 +740,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let time_noticed_needed = time_noticed_start.elapsed().unwrap_or_default();
 
             println!(
-                "{:?} to create this list, {:?} to mark all messages as noticed.",
-                time_needed, time_noticed_needed
+                "{time_needed:?} to create this list, {time_noticed_needed:?} to mark all messages as noticed."
             );
         }
         "createchat" => {
@@ -721,26 +748,26 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let contact_id = ContactId::new(arg1.parse()?);
             let chat_id = ChatId::create_for_contact(&context, contact_id).await?;
 
-            println!("Single#{} created successfully.", chat_id,);
+            println!("Single#{chat_id} created successfully.",);
         }
         "creategroup" => {
             ensure!(!arg1.is_empty(), "Argument <name> missing.");
             let chat_id =
                 chat::create_group_chat(&context, ProtectionStatus::Unprotected, arg1).await?;
 
-            println!("Group#{} created successfully.", chat_id);
+            println!("Group#{chat_id} created successfully.");
         }
         "createbroadcast" => {
             let chat_id = chat::create_broadcast_list(&context).await?;
 
-            println!("Broadcast#{} created successfully.", chat_id);
+            println!("Broadcast#{chat_id} created successfully.");
         }
         "createprotected" => {
             ensure!(!arg1.is_empty(), "Argument <name> missing.");
             let chat_id =
                 chat::create_group_chat(&context, ProtectionStatus::Protected, arg1).await?;
 
-            println!("Group#{} created and protected successfully.", chat_id);
+            println!("Group#{chat_id} created and protected successfully.");
         }
         "addmember" => {
             ensure!(sel_chat.is_some(), "No chat selected");
@@ -770,7 +797,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             chat::set_chat_name(
                 &context,
                 sel_chat.as_ref().unwrap().get_id(),
-                format!("{} {}", arg1, arg2).trim(),
+                format!("{arg1} {arg2}").trim(),
             )
             .await?;
 
@@ -787,15 +814,30 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         }
         "chatinfo" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
+            let sel_chat_id = sel_chat.as_ref().unwrap().get_id();
 
-            let contacts =
-                chat::get_chat_contacts(&context, sel_chat.as_ref().unwrap().get_id()).await?;
+            let contacts = chat::get_chat_contacts(&context, sel_chat_id).await?;
             println!("Memberlist:");
 
             log_contactlist(&context, &contacts).await?;
+            println!("{} contacts", contacts.len());
+
+            let similar_chats = sel_chat_id.get_similar_chat_ids(&context).await?;
+            if !similar_chats.is_empty() {
+                println!("Similar chats: ");
+                for (similar_chat_id, metric) in similar_chats {
+                    let similar_chat = Chat::load_from_db(&context, similar_chat_id).await?;
+                    println!(
+                        "{} (#{}) {:.1}",
+                        similar_chat.name,
+                        similar_chat_id,
+                        100.0 * metric
+                    );
+                }
+            }
+
             println!(
-                "{} contacts\nLocation streaming: {}",
-                contacts.len(),
+                "Location streaming: {}",
                 location::is_sending_locations_to_chat(
                     &context,
                     Some(sel_chat.as_ref().unwrap().get_id())
@@ -860,11 +902,11 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let latitude = arg1.parse()?;
             let longitude = arg2.parse()?;
 
-            let continue_streaming = location::set(&context, latitude, longitude, 0.).await;
+            let continue_streaming = location::set(&context, latitude, longitude, 0.).await?;
             if continue_streaming {
                 println!("Success, streaming should be continued.");
             } else {
-                println!("Success, streaming can be stoppped.");
+                println!("Success, streaming can be stopped.");
             }
         }
         "dellocations" => {
@@ -874,7 +916,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             ensure!(sel_chat.is_some(), "No chat selected.");
             ensure!(!arg1.is_empty(), "No message text given.");
 
-            let msg = format!("{} {}", arg1, arg2);
+            let msg = format!("{arg1} {arg2}");
 
             chat::send_text_msg(&context, sel_chat.as_ref().unwrap().get_id(), msg).await?;
         }
@@ -894,9 +936,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 Viewtype::File
             });
             msg.set_file(arg1, None);
-            if !arg2.is_empty() {
-                msg.set_text(Some(arg2.to_string()));
-            }
+            msg.set_text(arg2.to_string());
             chat::send_msg(&context, sel_chat.as_ref().unwrap().get_id(), &mut msg).await?;
         }
         "sendhtml" => {
@@ -908,15 +948,15 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
 
             let mut msg = Message::new(Viewtype::Text);
             msg.set_html(Some(html.to_string()));
-            msg.set_text(Some(if arg2.is_empty() {
+            msg.set_text(if arg2.is_empty() {
                 path.file_name().unwrap().to_string_lossy().to_string()
             } else {
                 arg2.to_string()
-            }));
+            });
             chat::send_msg(&context, sel_chat.as_ref().unwrap().get_id(), &mut msg).await?;
         }
         "sendsyncmsg" => match context.send_sync_msg().await? {
-            Some(msg_id) => println!("sync message sent as {}.", msg_id),
+            Some(msg_id) => println!("sync message sent as {msg_id}."),
             None => println!("sync message not needed."),
         },
         "sendupdate" => {
@@ -936,7 +976,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         "listmsgs" => {
             ensure!(!arg1.is_empty(), "Argument <query> missing.");
 
-            let query = format!("{} {}", arg1, arg2).trim().to_string();
+            let query = format!("{arg1} {arg2}").trim().to_string();
             let chat = sel_chat.as_ref().map(|sel_chat| sel_chat.get_id());
             let time_start = std::time::SystemTime::now();
             let msglist = context.search_msgs(chat, &query).await?;
@@ -954,14 +994,14 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 },
                 query,
             );
-            println!("{:?} to create this list", time_needed);
+            println!("{time_needed:?} to create this list");
         }
         "draft" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
 
             if !arg1.is_empty() {
                 let mut draft = Message::new(Viewtype::Text);
-                draft.set_text(Some(arg1.to_string()));
+                draft.set_text(arg1.to_string());
                 sel_chat
                     .as_ref()
                     .unwrap()
@@ -985,7 +1025,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 "Please specify text to add as device message."
             );
             let mut msg = Message::new(Viewtype::Text);
-            msg.set_text(Some(arg1.to_string()));
+            msg.set_text(arg1.to_string());
             chat::add_device_msg(&context, None, Some(&mut msg)).await?;
         }
         "listmedia" => {
@@ -1000,9 +1040,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             println!("{} images or videos: ", images.len());
             for (i, data) in images.iter().enumerate() {
                 if 0 == i {
-                    print!("{}", data);
+                    print!("{data}");
                 } else {
-                    print!(", {}", data);
+                    print!(", {data}");
                 }
             }
             println!();
@@ -1040,20 +1080,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             };
             chat::set_muted(&context, chat_id, duration).await?;
         }
-        "protect" | "unprotect" => {
-            ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
-            let chat_id = ChatId::new(arg1.parse()?);
-            chat_id
-                .set_protection(
-                    &context,
-                    match arg0 {
-                        "protect" => ProtectionStatus::Protected,
-                        "unprotect" => ProtectionStatus::Unprotected,
-                        _ => unreachable!("arg0={:?}", arg0),
-                    },
-                )
-                .await?;
-        }
         "delchat" => {
             ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
             let chat_id = ChatId::new(arg1.parse()?);
@@ -1072,13 +1098,13 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         "msginfo" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
             let id = MsgId::new(arg1.parse()?);
-            let res = message::get_msg_info(&context, id).await?;
-            println!("{}", res);
+            let res = id.get_info(&context).await?;
+            println!("{res}");
         }
         "download" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
             let id = MsgId::new(arg1.parse()?);
-            println!("Scheduling download for {:?}", id);
+            println!("Scheduling download for {id:?}");
             id.download_full(&context).await?;
         }
         "html" => {
@@ -1089,7 +1115,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 .join(format!("msg-{}.html", id.to_u32()));
             let html = id.get_html(&context).await?.unwrap_or_default();
             fs::write(&file, html).await?;
-            println!("HTML written to: {:#?}", file);
+            println!("HTML written to: {file:#?}");
         }
         "listfresh" => {
             let msglist = context.get_fresh_msgs().await?;
@@ -1151,7 +1177,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             ensure!(!arg1.is_empty(), "Arguments [<name>] <addr> expected.");
 
             if !arg2.is_empty() {
-                let book = format!("{}\n{}", arg1, arg2);
+                let book = format!("{arg1}\n{arg2}");
                 Contact::add_address_book(&context, &book).await?;
             } else {
                 Contact::create(&context, "", arg1).await?;
@@ -1178,10 +1204,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let chatlist = Chatlist::try_load(&context, 0, None, Some(contact_id)).await?;
             let chatlist_cnt = chatlist.len();
             if chatlist_cnt > 0 {
-                res += &format!(
-                    "\n\n{} chats shared with Contact#{}: ",
-                    chatlist_cnt, contact_id,
-                );
+                res += &format!("\n\n{chatlist_cnt} chats shared with Contact#{contact_id}: ",);
                 for i in 0..chatlist_cnt {
                     if 0 != i {
                         res += ", ";
@@ -1191,7 +1214,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 }
             }
 
-            println!("{}", res);
+            println!("{res}");
         }
         "delcontact" => {
             ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
@@ -1215,13 +1238,13 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         "checkqr" => {
             ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");
             let qr = check_qr(&context, arg1).await?;
-            println!("qr={:?}", qr);
+            println!("qr={qr:?}");
         }
         "setqr" => {
             ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");
             match set_config_from_qr(&context, arg1).await {
                 Ok(()) => println!("Config set from QR code, you can now call 'configure'"),
-                Err(err) => println!("Cannot set config from QR code: {:?}", err),
+                Err(err) => println!("Cannot set config from QR code: {err:?}"),
             }
         }
         "providerinfo" => {
@@ -1231,7 +1254,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 .await?;
             match provider::get_provider_info(&context, arg1, socks5_enabled).await {
                 Some(info) => {
-                    println!("Information for provider belonging to {}:", arg1);
+                    println!("Information for provider belonging to {arg1}:");
                     println!("status: {}", info.status as u32);
                     println!("before_login_hint: {}", info.before_login_hint);
                     println!("after_login_hint: {}", info.after_login_hint);
@@ -1241,7 +1264,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                     }
                 }
                 None => {
-                    println!("No information for provider belonging to {} found.", arg1);
+                    println!("No information for provider belonging to {arg1} found.");
                 }
             }
         }
@@ -1250,7 +1273,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
 
             if let Ok(buf) = read_file(&context, &arg1).await {
                 let (width, height) = get_filemeta(&buf)?;
-                println!("width={}, height={}", width, height);
+                println!("width={width}, height={height}");
             } else {
                 bail!("Command failed.");
             }
@@ -1261,8 +1284,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let device_cnt = message::estimate_deletion_cnt(&context, false, seconds).await?;
             let server_cnt = message::estimate_deletion_cnt(&context, true, seconds).await?;
             println!(
-                "estimated count of messages older than {} seconds:\non device: {}\non server: {}",
-                seconds, device_cnt, server_cnt
+                "estimated count of messages older than {seconds} seconds:\non device: {device_cnt}\non server: {server_cnt}"
             );
         }
         "" => (),

deltachat-repl/src/main.rs

@@ -67,8 +67,7 @@ fn receive_event(event: EventType) {
             info!(
                 "{}",
                 yellow.paint(format!(
-                    "Received MSGS_CHANGED(chat_id={}, msg_id={})",
-                    chat_id, msg_id,
+                    "Received MSGS_CHANGED(chat_id={chat_id}, msg_id={msg_id})",
                 ))
             );
         }
@@ -80,8 +79,7 @@ fn receive_event(event: EventType) {
             info!(
                 "{}",
                 yellow.paint(format!(
-                    "Received REACTIONS_CHANGED(chat_id={}, msg_id={}, contact_id={})",
-                    chat_id, msg_id, contact_id
+                    "Received REACTIONS_CHANGED(chat_id={chat_id}, msg_id={msg_id}, contact_id={contact_id})"
                 ))
             );
         }
@@ -91,7 +89,7 @@ fn receive_event(event: EventType) {
         EventType::LocationChanged(contact) => {
             info!(
                 "{}",
-                yellow.paint(format!("Received LOCATION_CHANGED(contact={:?})", contact))
+                yellow.paint(format!("Received LOCATION_CHANGED(contact={contact:?})"))
             );
         }
         EventType::ConfigureProgress { progress, comment } => {
@@ -99,21 +97,20 @@ fn receive_event(event: EventType) {
                 info!(
                     "{}",
                     yellow.paint(format!(
-                        "Received CONFIGURE_PROGRESS({} ‰, {})",
-                        progress, comment
+                        "Received CONFIGURE_PROGRESS({progress} ‰, {comment})"
                     ))
                 );
             } else {
                 info!(
                     "{}",
-                    yellow.paint(format!("Received CONFIGURE_PROGRESS({} ‰)", progress))
+                    yellow.paint(format!("Received CONFIGURE_PROGRESS({progress} ‰)"))
                 );
             }
         }
         EventType::ImexProgress(progress) => {
             info!(
                 "{}",
-                yellow.paint(format!("Received IMEX_PROGRESS({} ‰)", progress))
+                yellow.paint(format!("Received IMEX_PROGRESS({progress} ‰)"))
             );
         }
         EventType::ImexFileWritten(file) => {
@@ -125,7 +122,7 @@ fn receive_event(event: EventType) {
         EventType::ChatModified(chat) => {
             info!(
                 "{}",
-                yellow.paint(format!("Received CHAT_MODIFIED({})", chat))
+                yellow.paint(format!("Received CHAT_MODIFIED({chat})"))
             );
         }
         _ => {
@@ -155,13 +152,15 @@ impl Completer for DcHelper {
     }
 }
 
-const IMEX_COMMANDS: [&str; 12] = [
+const IMEX_COMMANDS: [&str; 14] = [
     "initiate-key-transfer",
     "get-setupcodebegin",
     "continue-key-transfer",
     "has-backup",
     "export-backup",
     "import-backup",
+    "send-backup",
+    "receive-backup",
     "export-keys",
     "import-keys",
     "export-setup",
@@ -353,8 +352,8 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
             match readline {
                 Ok(line) => {
                     // TODO: ignore "set mail_pw"
-                    rl.add_history_entry(line.as_str());
-                    let contine = Handle::current().block_on(async {
+                    rl.add_history_entry(line.as_str())?;
+                    let should_continue = Handle::current().block_on(async {
                         match handle_cmd(line.trim(), ctx.clone(), &mut selected_chat).await {
                             Ok(ExitResult::Continue) => true,
                             Ok(ExitResult::Exit) => {
@@ -362,13 +361,13 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
                                 false
                             }
                             Err(err) => {
-                                println!("Error: {}", err);
+                                println!("Error: {err:#}");
                                 true
                             }
                         }
                     });
 
-                    if !contine {
+                    if !should_continue {
                         break;
                     }
                 }
@@ -377,7 +376,7 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
                     break;
                 }
                 Err(err) => {
-                    println!("Error: {}", err);
+                    println!("Error: {err:#}");
                     break;
                 }
             }
@@ -444,7 +443,7 @@ async fn handle_cmd(
                 if arg0 == "getbadqr" && qr.len() > 40 {
                     qr.replace_range(12..22, "0000000000")
                 }
-                println!("{}", qr);
+                println!("{qr}");
                 let output = Command::new("qrencode")
                     .args(["-t", "ansiutf8", qr.as_str(), "-o", "-"])
                     .output()
@@ -460,7 +459,7 @@ async fn handle_cmd(
             match get_securejoin_qr_svg(&ctx, group).await {
                 Ok(svg) => {
                     fs::write(&file, svg).await?;
-                    println!("QR code svg written to: {:#?}", file);
+                    println!("QR code svg written to: {file:#?}");
                 }
                 Err(err) => {
                     bail!("Failed to get QR code svg: {}", err);

deltachat-rpc-client/LICENSE

@@ -0,0 +1,373 @@
+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,9 +5,23 @@ 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`.
+To use Delta Chat RPC client, first build a `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`
+or download a prebuilt release.
 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`.
@@ -23,19 +37,14 @@ $ tox --devenv env
 $ . env/bin/activate
 ```
 
-It is recommended to use IPython, because it supports using `await` directly
-from the REPL.
-
 ```
-$ 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()
+$ 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()
 ```

deltachat-rpc-client/examples/echobot.py

@@ -4,23 +4,21 @@
 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)
-async def log_event(event):
+def log_event(event):
     print(event)
 
 
 @hooks.on(events.NewMessage)
-async def echo(event):
+def echo(event):
     snapshot = event.message_snapshot
-    await snapshot.chat.send_text(snapshot.text)
+    snapshot.chat.send_text(snapshot.text)
 
 
 if __name__ == "__main__":
-    asyncio.run(run_bot_cli(hooks))
+    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,61 +13,62 @@ hooks = events.HookCollection()
 
 
 @hooks.on(events.RawEvent)
-async def log_event(event):
-    if event.type == EventType.INFO:
+def log_event(event):
+    if event.kind == EventType.INFO:
         logging.info(event.msg)
-    elif event.type == EventType.WARNING:
+    elif event.kind == EventType.WARNING:
         logging.warning(event.msg)
 
 
 @hooks.on(events.RawEvent(EventType.ERROR))
-async def log_error(event):
+def log_error(event):
     logging.error(event.msg)
 
 
 @hooks.on(events.MemberListChanged)
-async def on_memberlist_changed(event):
+def on_memberlist_changed(event):
     logging.info("member %s was %s", event.member, "added" if event.member_added else "removed")
 
 
 @hooks.on(events.GroupImageChanged)
-async def on_group_image_changed(event):
+def on_group_image_changed(event):
     logging.info("group image %s", "deleted" if event.image_deleted else "changed")
 
 
 @hooks.on(events.GroupNameChanged)
-async def on_group_name_changed(event):
+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))
-async def echo(event):
+def echo(event):
     snapshot = event.message_snapshot
     if snapshot.text or snapshot.file:
-        await snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
+        snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
 
 
 @hooks.on(events.NewMessage(command="/help"))
-async def help_command(event):
+def help_command(event):
     snapshot = event.message_snapshot
-    await snapshot.chat.send_text("Send me any message and I will echo it back")
+    snapshot.chat.send_text("Send me any message and I will echo it back")
 
 
-async def main():
-    async with Rpc() as rpc:
+def main():
+    with Rpc() as rpc:
         deltachat = DeltaChat(rpc)
-        system_info = await deltachat.get_system_info()
+        system_info = deltachat.get_system_info()
         logging.info("Running deltachat core %s", system_info.deltachat_core_version)
 
-        accounts = await deltachat.get_all_accounts()
-        account = accounts[0] if accounts else await deltachat.add_account()
+        accounts = deltachat.get_all_accounts()
+        account = accounts[0] if accounts else deltachat.add_account()
 
         bot = Bot(account, hooks)
-        if not await bot.is_configured():
-            asyncio.create_task(bot.configure(email=sys.argv[1], password=sys.argv[2]))
-        await bot.run_forever()
+        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 __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
+    main()

deltachat-rpc-client/examples/echobot_no_hooks.py

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

deltachat-rpc-client/pyproject.toml

@@ -5,21 +5,24 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "deltachat-rpc-client"
 description = "Python client for Delta Chat core JSON-RPC interface"
-dependencies = [
-    "aiohttp",
-    "aiodns"
+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"
 ]
 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"
@@ -28,11 +31,42 @@ 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", "F", "W", "N", "YTT", "B", "C4", "ISC", "ICN", "PT", "RET", "SIM", "TID", "ARG", "DTZ", "ERA", "PLC", "PLE", "PLW", "PIE", "COM"]
+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]

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

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

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

@@ -1,7 +1,7 @@
 import argparse
-import asyncio
 import re
 import sys
+from threading import Thread
 from typing import TYPE_CHECKING, Callable, Iterable, Optional, Tuple, Type, Union
 
 if TYPE_CHECKING:
@@ -27,7 +27,7 @@ def _to_attrdict(obj):
 
 
 class AttrDict(dict):
-    """Dictionary that allows accessing values usin the "dot notation" as attributes."""
+    """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()})
@@ -43,7 +43,7 @@ class AttrDict(dict):
         super().__setattr__(attr, val)
 
 
-async def run_client_cli(
+def run_client_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -54,10 +54,10 @@ async def run_client_cli(
     """
     from .client import Client
 
-    await _run_cli(Client, hooks, argv, **kwargs)
+    _run_cli(Client, hooks, argv, **kwargs)
 
 
-async def run_bot_cli(
+def run_bot_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -68,10 +68,10 @@ async def run_bot_cli(
     """
     from .client import Bot
 
-    await _run_cli(Bot, hooks, argv, **kwargs)
+    _run_cli(Bot, hooks, argv, **kwargs)
 
 
-async def _run_cli(
+def _run_cli(
     client_type: Type["Client"],
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
@@ -93,19 +93,20 @@ async def _run_cli(
     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:
+    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()
+        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 await client.is_configured():
+        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"
-            asyncio.create_task(client.configure(email=args.email, password=args.password))
-        await client.run_forever()
+            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:

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

@@ -1,95 +1,86 @@
+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, SpecialContactId
 from .contact import Contact
 from .message import Message
-from .rpc import Rpc
 
 if TYPE_CHECKING:
     from .deltachat import DeltaChat
+    from .rpc import Rpc
 
 
+@dataclass
 class Account:
     """Delta Chat account."""
 
-    def __init__(self, manager: "DeltaChat", account_id: int) -> None:
-        self.manager = manager
-        self.id = account_id
+    manager: "DeltaChat"
+    id: int
 
     @property
-    def _rpc(self) -> Rpc:
+    def _rpc(self) -> "Rpc":
         return self.manager.rpc
 
-    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:
+    def wait_for_event(self) -> AttrDict:
         """Wait until the next event and return it."""
-        return AttrDict(await self._rpc.wait_for_event(self.id))
+        return AttrDict(self._rpc.wait_for_event(self.id))
 
-    async def remove(self) -> None:
+    def remove(self) -> None:
         """Remove the account."""
-        await self._rpc.remove_account(self.id)
+        self._rpc.remove_account(self.id)
 
-    async def start_io(self) -> None:
+    def start_io(self) -> None:
         """Start the account I/O."""
-        await self._rpc.start_io(self.id)
+        self._rpc.start_io(self.id)
 
-    async def stop_io(self) -> None:
+    def stop_io(self) -> None:
         """Stop the account I/O."""
-        await self._rpc.stop_io(self.id)
+        self._rpc.stop_io(self.id)
 
-    async def get_info(self) -> AttrDict:
+    def get_info(self) -> AttrDict:
         """Return dictionary of this account configuration parameters."""
-        return AttrDict(await self._rpc.get_info(self.id))
+        return AttrDict(self._rpc.get_info(self.id))
 
-    async def get_size(self) -> int:
+    def get_size(self) -> int:
         """Get the combined filesize of an account in bytes."""
-        return await self._rpc.get_account_file_size(self.id)
+        return self._rpc.get_account_file_size(self.id)
 
-    async def is_configured(self) -> bool:
+    def is_configured(self) -> bool:
         """Return True if this account is configured."""
-        return await self._rpc.is_configured(self.id)
+        return self._rpc.is_configured(self.id)
 
-    async def set_config(self, key: str, value: Optional[str] = None) -> None:
+    def set_config(self, key: str, value: Optional[str] = None) -> None:
         """Set configuration value."""
-        await self._rpc.set_config(self.id, key, value)
+        self._rpc.set_config(self.id, key, value)
 
-    async def get_config(self, key: str) -> Optional[str]:
+    def get_config(self, key: str) -> Optional[str]:
         """Get configuration value."""
-        return await self._rpc.get_config(self.id, key)
+        return self._rpc.get_config(self.id, key)
 
-    async def update_config(self, **kwargs) -> None:
+    def update_config(self, **kwargs) -> None:
         """update config values."""
         for key, value in kwargs.items():
-            await self.set_config(key, value)
+            self.set_config(key, value)
 
-    async def set_avatar(self, img_path: Optional[str] = None) -> None:
+    def set_avatar(self, img_path: Optional[str] = None) -> None:
         """Set self avatar.
 
         Passing None will discard the currently set avatar.
         """
-        await self.set_config("selfavatar", img_path)
+        self.set_config("selfavatar", img_path)
 
-    async def get_avatar(self) -> Optional[str]:
+    def get_avatar(self) -> Optional[str]:
         """Get self avatar."""
-        return await self.get_config("selfavatar")
+        return self.get_config("selfavatar")
 
-    async def configure(self) -> None:
+    def configure(self) -> None:
         """Configure an account."""
-        await self._rpc.configure(self.id)
+        self._rpc.configure(self.id)
 
-    async def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
+    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
@@ -103,24 +94,24 @@ class Account:
         if isinstance(obj, int):
             obj = Contact(self, obj)
         if isinstance(obj, Contact):
-            obj = (await obj.get_snapshot()).address
-        return Contact(self, await self._rpc.create_contact(self.id, obj, name))
+            obj = obj.get_snapshot().address
+        return Contact(self, self._rpc.create_contact(self.id, obj, name))
 
     def get_contact_by_id(self, contact_id: int) -> Contact:
         """Return Contact instance for the given contact ID."""
         return Contact(self, contact_id)
 
-    async def get_contact_by_addr(self, address: str) -> Optional[Contact]:
+    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 = await self._rpc.lookup_contact_id_by_addr(self.id, address)
+        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
         return contact_id and Contact(self, contact_id)
 
-    async def get_blocked_contacts(self) -> List[AttrDict]:
+    def get_blocked_contacts(self) -> List[AttrDict]:
         """Return a list with snapshots of all blocked contacts."""
-        contacts = await self._rpc.get_blocked_contacts(self.id)
+        contacts = self._rpc.get_blocked_contacts(self.id)
         return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
 
-    async def get_contacts(
+    def get_contacts(
         self,
         query: Optional[str] = None,
         with_self: bool = False,
@@ -142,9 +133,9 @@ class Account:
             flags |= ContactFlag.ADD_SELF
 
         if snapshot:
-            contacts = await self._rpc.get_contacts(self.id, flags, query)
+            contacts = 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)
+        contacts = self._rpc.get_contact_ids(self.id, flags, query)
         return [Contact(self, contact_id) for contact_id in contacts]
 
     @property
@@ -152,7 +143,7 @@ class Account:
         """This account's identity as a Contact."""
         return Contact(self, SpecialContactId.SELF)
 
-    async def get_chatlist(
+    def get_chatlist(
         self,
         query: Optional[str] = None,
         contact: Optional[Contact] = None,
@@ -168,7 +159,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 withot "Device chat" and contact requests.
+                               and without "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.
@@ -184,29 +175,29 @@ class Account:
         if alldone_hint:
             flags |= ChatlistFlag.ADD_ALLDONE_HINT
 
-        entries = await self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
+        entries = self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
         if not snapshot:
-            return [Chat(self, entry[0]) for entry in entries]
+            return [Chat(self, entry) for entry in entries]
 
-        items = await self._rpc.get_chatlist_items_by_entries(self.id, entries)
+        items = 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
 
-    async def create_group(self, name: str, protect: bool = False) -> Chat:
+    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, await self._rpc.create_group_chat(self.id, name, protect))
+        return Chat(self, self._rpc.create_group_chat(self.id, name, protect))
 
     def get_chat_by_id(self, chat_id: int) -> Chat:
         """Return the Chat instance with the given ID."""
         return Chat(self, chat_id)
 
-    async def secure_join(self, qrdata: str) -> Chat:
+    def secure_join(self, qrdata: str) -> Chat:
         """Continue a Setup-Contact or Verified-Group-Invite protocol started on
         another device.
 
@@ -217,39 +208,62 @@ class Account:
 
         :param qrdata: The text of the scanned QR code.
         """
-        return Chat(self, await self._rpc.secure_join(self.id, qrdata))
+        return Chat(self, self._rpc.secure_join(self.id, qrdata))
 
-    async def get_qr_code(self) -> Tuple[str, str]:
+    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 await self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
+        return self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
 
     def get_message_by_id(self, msg_id: int) -> Message:
         """Return the Message instance with the given ID."""
         return Message(self, msg_id)
 
-    async def mark_seen_messages(self, messages: List[Message]) -> None:
+    def mark_seen_messages(self, messages: List[Message]) -> None:
         """Mark the given set of messages as seen."""
-        await self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
+        self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
 
-    async def delete_messages(self, messages: List[Message]) -> None:
+    def delete_messages(self, messages: List[Message]) -> None:
         """Delete messages (local and remote)."""
-        await self._rpc.delete_messages(self.id, [msg.id for msg in messages])
+        self._rpc.delete_messages(self.id, [msg.id for msg in messages])
 
-    async def get_fresh_messages(self) -> List[Message]:
+    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 = await self._rpc.get_fresh_msgs(self.id)
+        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
 
-    async def get_fresh_messages_in_arrival_order(self) -> List[Message]:
+    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 get_fresh_messages_in_arrival_order(self) -> List[Message]:
         """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
-        fresh_msg_ids = sorted(await self._rpc.get_fresh_msgs(self.id))
+        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))
         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,40 +1,31 @@
 import calendar
-from datetime import datetime
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
 
 from ._utils import AttrDict
-from .const import ChatVisibility
+from .const import ChatVisibility, ViewType
 from .contact import Contact
 from .message import Message
-from .rpc import Rpc
 
 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."""
 
-    def __init__(self, account: "Account", chat_id: int) -> None:
-        self.account = account
-        self.id = chat_id
+    account: "Account"
+    id: int
 
     @property
-    def _rpc(self) -> Rpc:
+    def _rpc(self) -> "Rpc":
         return self.account._rpc
 
-    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:
+    def delete(self) -> None:
         """Delete this chat and all its messages.
 
         Note:
@@ -42,130 +33,147 @@ class Chat:
         - does not delete messages on server
         - the chat or contact is not blocked, new message will arrive
         """
-        await self._rpc.delete_chat(self.account.id, self.id)
+        self._rpc.delete_chat(self.account.id, self.id)
 
-    async def block(self) -> None:
+    def block(self) -> None:
         """Block this chat."""
-        await self._rpc.block_chat(self.account.id, self.id)
+        self._rpc.block_chat(self.account.id, self.id)
 
-    async def accept(self) -> None:
+    def accept(self) -> None:
         """Accept this contact request chat."""
-        await self._rpc.accept_chat(self.account.id, self.id)
+        self._rpc.accept_chat(self.account.id, self.id)
 
-    async def leave(self) -> None:
+    def leave(self) -> None:
         """Leave this chat."""
-        await self._rpc.leave_group(self.account.id, self.id)
+        self._rpc.leave_group(self.account.id, self.id)
 
-    async def mute(self, duration: Optional[int] = None) -> None:
+    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: Union[str, dict] = {"Until": duration}
+            dur: dict = {"kind": "Until", "duration": duration}
         else:
-            dur = "Forever"
-        await self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
+            dur = {"kind": "Forever"}
+        self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
 
-    async def unmute(self) -> None:
+    def unmute(self) -> None:
         """Unmute this chat."""
-        await self._rpc.set_chat_mute_duration(self.account.id, self.id, "NotMuted")
+        self._rpc.set_chat_mute_duration(self.account.id, self.id, {"kind": "NotMuted"})
 
-    async def pin(self) -> None:
+    def pin(self) -> None:
         """Pin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
 
-    async def unpin(self) -> None:
+    def unpin(self) -> None:
         """Unpin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
 
-    async def archive(self) -> None:
+    def archive(self) -> None:
         """Archive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
 
-    async def unarchive(self) -> None:
+    def unarchive(self) -> None:
         """Unarchive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
 
-    async def set_name(self, name: str) -> None:
+    def set_name(self, name: str) -> None:
         """Set name of this chat."""
-        await self._rpc.set_chat_name(self.account.id, self.id, name)
+        self._rpc.set_chat_name(self.account.id, self.id, name)
 
-    async def set_ephemeral_timer(self, timer: int) -> None:
+    def set_ephemeral_timer(self, timer: int) -> None:
         """Set ephemeral timer of this chat."""
-        await self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
+        self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
 
-    async def get_encryption_info(self) -> str:
+    def get_encryption_info(self) -> str:
         """Return encryption info for this chat."""
-        return await self._rpc.get_chat_encryption_info(self.account.id, self.id)
+        return self._rpc.get_chat_encryption_info(self.account.id, self.id)
 
-    async def get_qr_code(self) -> Tuple[str, str]:
+    def get_qr_code(self) -> Tuple[str, str]:
         """Get Join-Group QR code text and SVG data."""
-        return await self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
+        return self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
 
-    async def get_basic_snapshot(self) -> AttrDict:
+    def get_basic_snapshot(self) -> AttrDict:
         """Get a chat snapshot with basic info about this chat."""
-        info = await self._rpc.get_basic_chat_info(self.account.id, self.id)
+        info = self._rpc.get_basic_chat_info(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    async def get_full_snapshot(self) -> AttrDict:
+    def get_full_snapshot(self) -> AttrDict:
         """Get a full snapshot of this chat."""
-        info = await self._rpc.get_full_chat_by_id(self.account.id, self.id)
+        info = self._rpc.get_full_chat_by_id(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    async def send_message(
+    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(
         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
 
-        msg_id, _ = await self._rpc.misc_send_msg(self.account.id, self.id, text, file, location, quoted_msg)
+        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)
         return Message(self.account, msg_id)
 
-    async def send_text(self, text: str) -> Message:
+    def send_text(self, text: str) -> Message:
         """Send a text message and return the resulting Message instance."""
-        msg_id = await self._rpc.misc_send_text_message(self.account.id, self.id, text)
+        msg_id = self._rpc.misc_send_text_message(self.account.id, self.id, text)
         return Message(self.account, msg_id)
 
-    async def send_videochat_invitation(self) -> Message:
+    def send_videochat_invitation(self) -> Message:
         """Send a videochat invitation and return the resulting Message instance."""
-        msg_id = await self._rpc.send_videochat_invitation(self.account.id, self.id)
+        msg_id = self._rpc.send_videochat_invitation(self.account.id, self.id)
         return Message(self.account, msg_id)
 
-    async def send_sticker(self, path: str) -> Message:
+    def send_sticker(self, path: str) -> Message:
         """Send an sticker and return the resulting Message instance."""
-        msg_id = await self._rpc.send_sticker(self.account.id, self.id, path)
+        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
         return Message(self.account, msg_id)
 
-    async def forward_messages(self, messages: List[Message]) -> None:
+    def forward_messages(self, messages: List[Message]) -> None:
         """Forward a list of messages to this chat."""
         msg_ids = [msg.id for msg in messages]
-        await self._rpc.forward_messages(self.account.id, msg_ids, self.id)
+        self._rpc.forward_messages(self.account.id, msg_ids, self.id)
 
-    async def set_draft(
+    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
-        await self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg)
+        self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg, viewtype)
 
-    async def remove_draft(self) -> None:
+    def remove_draft(self) -> None:
         """Remove draft message."""
-        await self._rpc.remove_draft(self.account.id, self.id)
+        self._rpc.remove_draft(self.account.id, self.id)
 
-    async def get_draft(self) -> Optional[AttrDict]:
+    def get_draft(self) -> Optional[AttrDict]:
         """Get draft message."""
-        snapshot = await self._rpc.get_draft(self.account.id, self.id)
+        snapshot = self._rpc.get_draft(self.account.id, self.id)
         if not snapshot:
             return None
         snapshot = AttrDict(snapshot)
@@ -174,74 +182,78 @@ class Chat:
         snapshot["message"] = Message(self.account, snapshot.id)
         return snapshot
 
-    async def get_messages(self, flags: int = 0) -> List[Message]:
+    def get_messages(self, info_only: bool = False, add_daymarker: bool = False) -> List[Message]:
         """get the list of messages in this chat."""
-        msgs = await self._rpc.get_message_ids(self.account.id, self.id, flags)
+        msgs = self._rpc.get_message_ids(self.account.id, self.id, info_only, add_daymarker)
         return [Message(self.account, msg_id) for msg_id in msgs]
 
-    async def get_fresh_message_count(self) -> int:
+    def get_fresh_message_count(self) -> int:
         """Get number of fresh messages in this chat"""
-        return await self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
+        return self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
 
-    async def mark_noticed(self) -> None:
+    def mark_noticed(self) -> None:
         """Mark all messages in this chat as noticed."""
-        await self._rpc.marknoticed_chat(self.account.id, self.id)
+        self._rpc.marknoticed_chat(self.account.id, self.id)
 
-    async def add_contact(self, *contact: Union[int, str, Contact]) -> None:
+    def add_contact(self, *contact: Union[int, str, Contact]) -> None:
         """Add contacts to this group."""
         for cnt in contact:
             if isinstance(cnt, str):
-                cnt = (await self.account.create_contact(cnt)).id
+                contact_id = self.account.create_contact(cnt).id
             elif not isinstance(cnt, int):
-                cnt = cnt.id
-            await self._rpc.add_contact_to_chat(self.account.id, self.id, cnt)
+                contact_id = cnt.id
+            else:
+                contact_id = cnt
+            self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)
 
-    async def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
+    def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
         """Remove members from this group."""
         for cnt in contact:
             if isinstance(cnt, str):
-                cnt = (await self.account.create_contact(cnt)).id
+                contact_id = self.account.create_contact(cnt).id
             elif not isinstance(cnt, int):
-                cnt = cnt.id
-            await self._rpc.remove_contact_from_chat(self.account.id, self.id, cnt)
+                contact_id = cnt.id
+            else:
+                contact_id = cnt
+            self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)
 
-    async def get_contacts(self) -> List[Contact]:
+    def get_contacts(self) -> List[Contact]:
         """Get the contacts belonging to this chat.
 
         For single/direct chats self-address is not included.
         """
-        contacts = await self._rpc.get_chat_contacts(self.account.id, self.id)
+        contacts = self._rpc.get_chat_contacts(self.account.id, self.id)
         return [Contact(self.account, contact_id) for contact_id in contacts]
 
-    async def set_image(self, path: str) -> None:
+    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.
         """
-        await self._rpc.set_chat_profile_image(self.account.id, self.id, path)
+        self._rpc.set_chat_profile_image(self.account.id, self.id, path)
 
-    async def remove_image(self) -> None:
+    def remove_image(self) -> None:
         """Remove profile image of this chat."""
-        await self._rpc.set_chat_profile_image(self.account.id, self.id, None)
+        self._rpc.set_chat_profile_image(self.account.id, self.id, None)
 
-    async def get_locations(
+    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_to = calendar.timegm(timestamp_to.utctimetuple()) if timestamp_to else 0
         contact_id = contact.id if contact else 0
 
-        result = await self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
+        result = self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
         locations = []
         contacts: Dict[int, Contact] = {}
         for loc in result:
-            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)
+            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)
         return locations

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

@@ -1,9 +1,8 @@
 """Event loop implementations offering high level event handling/hooking."""
-import inspect
 import logging
 from typing import (
+    TYPE_CHECKING,
     Callable,
-    Coroutine,
     Dict,
     Iterable,
     Optional,
@@ -13,15 +12,13 @@ from typing import (
     Union,
 )
 
-from deltachat_rpc_client.account import Account
-
 from ._utils import (
     AttrDict,
     parse_system_add_remove,
     parse_system_image_changed,
     parse_system_title_changed,
 )
-from .const import COMMAND_PREFIX, EventType, SystemMessageType
+from .const import COMMAND_PREFIX, EventType, SpecialContactId, SystemMessageType
 from .events import (
     EventFilter,
     GroupImageChanged,
@@ -31,13 +28,16 @@ from .events import (
     RawEvent,
 )
 
+if TYPE_CHECKING:
+    from deltachat_rpc_client.account import Account
+
 
 class Client:
     """Simple Delta Chat client that listen to events of a single account."""
 
     def __init__(
         self,
-        account: Account,
+        account: "Account",
         hooks: Optional[Iterable[Tuple[Callable, Union[type, EventFilter]]]] = None,
         logger: Optional[logging.Logger] = None,
     ) -> None:
@@ -76,22 +76,22 @@ class Client:
         )
         self._hooks.get(type(event), set()).remove((hook, event))
 
-    async def is_configured(self) -> bool:
-        return await self.account.is_configured()
+    def is_configured(self) -> bool:
+        return self.account.is_configured()
 
-    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)
+    def configure(self, email: str, password: str, **kwargs) -> None:
+        self.account.set_config("addr", email)
+        self.account.set_config("mail_pw", password)
         for key, value in kwargs.items():
-            await self.account.set_config(key, value)
-        await self.account.configure()
+            self.account.set_config(key, value)
+        self.account.configure()
         self.logger.debug("Account configured")
 
-    async def run_forever(self) -> None:
+    def run_forever(self) -> None:
         """Process events forever."""
-        await self.run_until(lambda _: False)
+        self.run_until(lambda _: False)
 
-    async def run_until(self, func: Callable[[AttrDict], Union[bool, Coroutine]]) -> AttrDict:
+    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
@@ -99,39 +99,37 @@ class Client:
         evaluates to True.
         """
         self.logger.debug("Listening to incoming events...")
-        if await self.is_configured():
-            await self.account.start_io()
-        await self._process_messages()  # Process old messages.
+        if self.is_configured():
+            self.account.start_io()
+        self._process_messages()  # Process old messages.
         while True:
-            event = await self.account.wait_for_event()
-            event["type"] = EventType(event.type)
+            event = self.account.wait_for_event()
+            event["kind"] = EventType(event.kind)
             event["account"] = self.account
-            await self._on_event(event)
-            if event.type == EventType.INCOMING_MSG:
-                await self._process_messages()
+            self._on_event(event)
+            if event.kind == EventType.INCOMING_MSG:
+                self._process_messages()
 
             stop = func(event)
-            if inspect.isawaitable(stop):
-                stop = await stop
             if stop:
                 return event
 
-    async def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
+    def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
         for hook, evfilter in self._hooks.get(filter_type, []):
-            if await evfilter.filter(event):
+            if evfilter.filter(event):
                 try:
-                    await hook(event)
+                    hook(event)
                 except Exception as ex:
                     self.logger.exception(ex)
 
-    async def _parse_command(self, event: AttrDict) -> None:
+    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)
 
         if "@" in cmd:
-            suffix = "@" + (await self.account.self_contact.get_snapshot()).address
+            suffix = "@" + self.account.self_contact.get_snapshot().address
             if cmd.endswith(suffix):
                 cmd = cmd[: -len(suffix)]
             else:
@@ -151,32 +149,32 @@ class Client:
 
         event["command"], event["payload"] = cmd, payload
 
-    async def _on_new_msg(self, snapshot: AttrDict) -> None:
+    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):
-            await self._parse_command(event)
-        await self._on_event(event, NewMessage)
+            self._parse_command(event)
+        self._on_event(event, NewMessage)
 
-    async def _handle_info_msg(self, snapshot: AttrDict) -> None:
+    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
-            await self._on_event(event, GroupImageChanged)
+            self._on_event(event, GroupImageChanged)
             return
 
         title_changed = parse_system_title_changed(snapshot.text)
         if title_changed:
             _, event["old_name"] = title_changed
-            await self._on_event(event, GroupNameChanged)
+            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"
-            await self._on_event(event, MemberListChanged)
+            self._on_event(event, MemberListChanged)
             return
 
         self.logger.warning(
@@ -185,19 +183,20 @@ class Client:
             snapshot.text,
         )
 
-    async def _process_messages(self) -> None:
+    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()
-                await self._on_new_msg(snapshot)
+            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:
-                    await self._handle_info_msg(snapshot)
-                await snapshot.message.mark_seen()
+                    self._handle_info_msg(snapshot)
+                snapshot.message.mark_seen()
 
 
 class Bot(Client):
     """Simple bot implementation that listent to events of a single account."""
 
-    async def configure(self, email: str, password: str, **kwargs) -> None:
+    def configure(self, email: str, password: str, **kwargs) -> None:
         kwargs.setdefault("bot", "1")
-        await super().configure(email, password, **kwargs)
+        super().configure(email, password, **kwargs)

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

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

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

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

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

@@ -1,12 +1,13 @@
 """High-level classes for event processing and filtering."""
-import inspect
 import re
 from abc import ABC, abstractmethod
-from typing import Callable, Iterable, Iterator, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Set, Tuple, Union
 
-from ._utils import AttrDict
 from .const import EventType
 
+if TYPE_CHECKING:
+    from ._utils import AttrDict
+
 
 def _tuple_of(obj, type_: type) -> tuple:
     if not obj:
@@ -22,7 +23,7 @@ def _tuple_of(obj, type_: type) -> tuple:
 class EventFilter(ABC):
     """The base event filter.
 
-    :param func: A Callable (async or not) function that should accept the event as input
+    :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.
     """
@@ -41,16 +42,13 @@ class EventFilter(ABC):
     def __ne__(self, other):
         return not self == other
 
-    async def _call_func(self, event) -> bool:
+    def _call_func(self, event) -> bool:
         if not self.func:
             return True
-        res = self.func(event)
-        if inspect.isawaitable(res):
-            return await res
-        return res
+        return self.func(event)
 
     @abstractmethod
-    async def filter(self, event):
+    def filter(self, event):
         """Return True-like value if the event passed the filter and should be
         used, or False-like value otherwise.
         """
@@ -60,7 +58,7 @@ class RawEvent(EventFilter):
     """Matches raw core events.
 
     :param types: The types of event to match.
-    :param func: A Callable (async or not) function that should accept the event as input
+    :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.
     """
@@ -80,10 +78,10 @@ class RawEvent(EventFilter):
             return (self.types, self.func) == (other.types, other.func)
         return False
 
-    async def filter(self, event: AttrDict) -> bool:
-        if self.types and event.type not in self.types:
+    def filter(self, event: "AttrDict") -> bool:
+        if self.types and event.kind not in self.types:
             return False
-        return await self._call_func(event)
+        return self._call_func(event)
 
 
 class NewMessage(EventFilter):
@@ -96,10 +94,13 @@ class NewMessage(EventFilter):
                     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 (async or not) function that should accept the event as input
+    :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.
     """
@@ -113,10 +114,12 @@ class NewMessage(EventFilter):
             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")
@@ -133,30 +136,37 @@ class NewMessage(EventFilter):
             raise TypeError("Invalid pattern type")
 
     def __hash__(self) -> int:
-        return hash((self.pattern, self.func))
+        return hash((self.pattern, self.command, self.is_bot, self.is_info, self.func))
 
     def __eq__(self, other) -> bool:
         if isinstance(other, NewMessage):
-            return (self.pattern, self.command, self.is_info, self.func) == (
+            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,
             )
         return False
 
-    async def filter(self, event: AttrDict) -> bool:
+    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
         if self.pattern:
             match = self.pattern(event.message_snapshot.text)
-            if inspect.isawaitable(match):
-                match = await match
             if not match:
                 return False
-        return await super()._call_func(event)
+        return super()._call_func(event)
 
 
 class MemberListChanged(EventFilter):
@@ -168,7 +178,7 @@ class MemberListChanged(EventFilter):
     :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 (async or not) function that should accept the event as input
+    :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.
     """
@@ -185,10 +195,10 @@ class MemberListChanged(EventFilter):
             return (self.added, self.func) == (other.added, other.func)
         return False
 
-    async def filter(self, event: AttrDict) -> bool:
+    def filter(self, event: "AttrDict") -> bool:
         if self.added is not None and self.added != event.member_added:
             return False
-        return await self._call_func(event)
+        return self._call_func(event)
 
 
 class GroupImageChanged(EventFilter):
@@ -200,7 +210,7 @@ class GroupImageChanged(EventFilter):
     :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 (async or not) function that should accept the event as input
+    :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.
     """
@@ -217,10 +227,10 @@ class GroupImageChanged(EventFilter):
             return (self.deleted, self.func) == (other.deleted, other.func)
         return False
 
-    async def filter(self, event: AttrDict) -> bool:
+    def filter(self, event: "AttrDict") -> bool:
         if self.deleted is not None and self.deleted != event.image_deleted:
             return False
-        return await self._call_func(event)
+        return self._call_func(event)
 
 
 class GroupNameChanged(EventFilter):
@@ -229,7 +239,7 @@ class GroupNameChanged(EventFilter):
     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 (async or not) function that should accept the event as input
+    :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.
     """
@@ -242,8 +252,8 @@ class GroupNameChanged(EventFilter):
             return self.func == other.func
         return False
 
-    async def filter(self, event: AttrDict) -> bool:
-        return await self._call_func(event)
+    def filter(self, event: "AttrDict") -> bool:
+        return self._call_func(event)
 
 
 class HookCollection:

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

@@ -1,62 +1,59 @@
 import json
-from typing import TYPE_CHECKING, Union
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional, Union
 
 from ._utils import AttrDict
 from .contact import Contact
-from .rpc import Rpc
 
 if TYPE_CHECKING:
     from .account import Account
+    from .rpc import Rpc
 
 
+@dataclass
 class Message:
     """Delta Chat Message object."""
 
-    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}>"
+    account: "Account"
+    id: int
 
     @property
-    def _rpc(self) -> Rpc:
+    def _rpc(self) -> "Rpc":
         return self.account._rpc
 
-    async def send_reaction(self, *reaction: str):
+    def send_reaction(self, *reaction: str):
         """Send a reaction to this message."""
-        await self._rpc.send_reaction(self.account.id, self.id, reaction)
+        self._rpc.send_reaction(self.account.id, self.id, reaction)
 
-    async def get_snapshot(self) -> AttrDict:
+    def get_snapshot(self) -> AttrDict:
         """Get a snapshot with the properties of this message."""
         from .chat import Chat
 
-        snapshot = AttrDict(await self._rpc.get_message(self.account.id, self.id))
+        snapshot = AttrDict(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
 
-    async def mark_seen(self) -> None:
-        """Mark the message as seen."""
-        await self._rpc.markseen_msgs(self.account.id, [self.id])
+    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
 
-    async def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
+    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)
-        await self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
+        self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
 
-    async def get_webxdc_status_updates(self, last_known_serial: int = 0) -> list:
-        return json.loads(await self._rpc.get_webxdc_status_updates(self.account.id, self.id, last_known_serial))
+    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))
 
-    async def get_webxdc_info(self) -> dict:
-        return await self._rpc.get_webxdc_info(self.account.id, self.id)
+    def get_webxdc_info(self) -> dict:
+        return self._rpc.get_webxdc_info(self.account.id, self.id)

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

@@ -1,63 +1,65 @@
-import json
 import os
+import random
 from typing import AsyncGenerator, List, Optional
 
-import aiohttp
-import pytest_asyncio
+import pytest
 
 from . import Account, AttrDict, Bot, Client, DeltaChat, EventType, Message
 from .rpc import Rpc
 
 
-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"
-
-    # Replace default 5 minute timeout with a 1 minute timeout.
-    timeout = aiohttp.ClientTimeout(total=60)
-    async with aiohttp.ClientSession() as session:
-        async with session.post(url, timeout=timeout) as response:
-            return json.loads(await response.text())
+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}
 
 
 class ACFactory:
     def __init__(self, deltachat: DeltaChat) -> None:
         self.deltachat = deltachat
 
-    async def get_unconfigured_account(self) -> Account:
-        return await self.deltachat.add_account()
+    def get_unconfigured_account(self) -> Account:
+        return self.deltachat.add_account()
 
-    async def get_unconfigured_bot(self) -> Bot:
-        return Bot(await self.get_unconfigured_account())
+    def get_unconfigured_bot(self) -> Bot:
+        return Bot(self.get_unconfigured_account())
 
-    async def new_preconfigured_account(self) -> Account:
+    def new_preconfigured_account(self) -> Account:
         """Make a new account with configuration options set, but configuration not started."""
-        credentials = await get_temp_credentials()
-        account = await self.get_unconfigured_account()
-        await account.set_config("addr", credentials["email"])
-        await account.set_config("mail_pw", credentials["password"])
-        assert not await account.is_configured()
+        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
 
-    async def new_configured_account(self) -> Account:
-        account = await self.new_preconfigured_account()
-        await account.configure()
-        assert await account.is_configured()
+    def new_configured_account(self) -> Account:
+        account = self.new_preconfigured_account()
+        account.configure()
+        assert account.is_configured()
         return account
 
-    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"])
+    def new_configured_bot(self) -> Bot:
+        credentials = get_temp_credentials()
+        bot = self.get_unconfigured_bot()
+        bot.configure(credentials["email"], credentials["password"])
         return bot
 
-    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
+    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
 
-    async def send_message(
+    def get_online_accounts(self, num: int) -> List[Account]:
+        return [self.get_online_account() for _ in range(num)]
+
+    def send_message(
         self,
         to_account: Account,
         from_account: Optional[Account] = None,
@@ -66,16 +68,16 @@ class ACFactory:
         group: Optional[str] = None,
     ) -> Message:
         if not from_account:
-            from_account = (await self.get_online_accounts(1))[0]
-        to_contact = await from_account.create_contact(await to_account.get_config("addr"))
+            from_account = (self.get_online_accounts(1))[0]
+        to_contact = from_account.create_contact(to_account.get_config("addr"))
         if group:
-            to_chat = await from_account.create_group(group)
-            await to_chat.add_contact(to_contact)
+            to_chat = from_account.create_group(group)
+            to_chat.add_contact(to_contact)
         else:
-            to_chat = await to_contact.create_chat()
-        return await to_chat.send_message(text=text, file=file)
+            to_chat = to_contact.create_chat()
+        return to_chat.send_message(text=text, file=file)
 
-    async def process_message(
+    def process_message(
         self,
         to_client: Client,
         from_account: Optional[Account] = None,
@@ -83,7 +85,7 @@ class ACFactory:
         file: Optional[str] = None,
         group: Optional[str] = None,
     ) -> AttrDict:
-        await self.send_message(
+        self.send_message(
             to_account=to_client.account,
             from_account=from_account,
             text=text,
@@ -91,16 +93,16 @@ class ACFactory:
             group=group,
         )
 
-        return await to_client.run_until(lambda e: e.type == EventType.INCOMING_MSG)
+        return to_client.run_until(lambda e: e.kind == EventType.INCOMING_MSG)
 
 
-@pytest_asyncio.fixture
-async def rpc(tmp_path) -> AsyncGenerator:
+@pytest.fixture()
+def rpc(tmp_path) -> AsyncGenerator:
     rpc_server = Rpc(accounts_dir=str(tmp_path / "accounts"))
-    async with rpc_server:
+    with rpc_server:
         yield rpc_server
 
 
-@pytest_asyncio.fixture
-async def acfactory(rpc) -> AsyncGenerator:
-    yield ACFactory(DeltaChat(rpc))
+@pytest.fixture()
+def acfactory(rpc) -> AsyncGenerator:
+    return ACFactory(DeltaChat(rpc))

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

@@ -1,6 +1,10 @@
-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, Optional
 
 
@@ -10,7 +14,7 @@ class JsonRpcError(Exception):
 
 class Rpc:
     def __init__(self, accounts_dir: Optional[str] = None, **kwargs):
-        """The given arguments will be passed to asyncio.create_subprocess_exec()"""
+        """The given arguments will be passed to subprocess.Popen()"""
         if accounts_dir:
             kwargs["env"] = {
                 **kwargs.get("env", os.environ),
@@ -18,81 +22,142 @@ class Rpc:
             }
 
         self._kwargs = kwargs
-        self.process: asyncio.subprocess.Process
+        self.process: subprocess.Popen
         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
+        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
 
-    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,
-        )
+    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 = 0
         self.event_queues = {}
         self.request_events = {}
-        self.reader_task = asyncio.create_task(self.reader_loop())
+        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()
 
-    async def close(self) -> None:
+    def close(self) -> None:
         """Terminate RPC server process and wait until the reader loop finishes."""
-        self.process.terminate()
-        await self.reader_task
+        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()
 
-    async def __aenter__(self):
-        await self.start()
+    def __enter__(self):
+        self.start()
         return self
 
-    async def __aexit__(self, _exc_type, _exc, _tb):
-        await self.close()
+    def __exit__(self, _exc_type, _exc, _tb):
+        self.close()
 
-    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 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 wait_for_event(self, account_id: int) -> Optional[dict]:
+    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)
+                queue.put(event["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]:
         """Waits for the next event from the given account and returns it."""
-        if account_id in self.event_queues:
-            return await self.event_queues[account_id].get()
-        return None
+        queue = self.get_queue(account_id)
+        return queue.get()
 
     def __getattr__(self, attr: str):
-        async def method(*args, **kwargs) -> Any:
+        def method(*args) -> 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": kwargs or args,
+                "params": args,
                 "id": self.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
+            event = Event()
+            self.request_events[request_id] = event
+            self.request_queue.put(request)
+            event.wait()
+
+            response = self.request_results.pop(request_id)
             if "error" in response:
                 raise JsonRpcError(response["error"])
             if "result" in response:

deltachat-rpc-client/tests/test_something.py

@@ -1,20 +1,33 @@
+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.rpc import JsonRpcError
 
 
-@pytest.mark.asyncio()
-async def test_system_info(rpc) -> None:
-    system_info = await rpc.get_system_info()
+def test_system_info(rpc) -> None:
+    system_info = rpc.get_system_info()
     assert "arch" in system_info
     assert "deltachat_core_version" in system_info
 
 
-@pytest.mark.asyncio()
-async def test_email_address_validity(rpc) -> None:
+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:
     valid_addresses = [
         "email@example.com",
         "36aa165ae3406424e0c61af17700f397cad3fe8ab83d682d0bddf3338a5dd52e@yggmail@yggmail",
@@ -22,17 +35,16 @@ async def test_email_address_validity(rpc) -> None:
     invalid_addresses = ["email@", "example.com", "emai221"]
 
     for addr in valid_addresses:
-        assert await rpc.check_email_validity(addr)
+        assert rpc.check_email_validity(addr)
     for addr in invalid_addresses:
-        assert not await rpc.check_email_validity(addr)
+        assert not rpc.check_email_validity(addr)
 
 
-@pytest.mark.asyncio()
-async def test_acfactory(acfactory) -> None:
-    account = await acfactory.new_configured_account()
+def test_acfactory(acfactory) -> None:
+    account = acfactory.new_configured_account()
     while True:
-        event = await account.wait_for_event()
-        if event.type == EventType.CONFIGURE_PROGRESS:
+        event = account.wait_for_event()
+        if event.kind == EventType.CONFIGURE_PROGRESS:
             assert event.progress != 0  # Progress 0 indicates error.
             if event.progress == 1000:  # Success
                 break
@@ -41,203 +53,242 @@ async def test_acfactory(acfactory) -> None:
     print("Successful configuration")
 
 
-@pytest.mark.asyncio()
-async def test_configure_starttls(acfactory) -> None:
-    account = await acfactory.new_preconfigured_account()
+def test_configure_starttls(acfactory) -> None:
+    account = acfactory.new_preconfigured_account()
 
     # Use STARTTLS
-    await account.set_config("mail_security", "2")
-    await account.configure()
-    assert await account.is_configured()
+    account.set_config("mail_security", "2")
+    account.set_config("send_security", "2")
+    account.configure()
+    assert account.is_configured()
 
 
-@pytest.mark.asyncio()
-async def test_account(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_account(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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!")
+    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!")
 
     while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
     message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
-    await bob.mark_seen_messages([message])
+    bob.mark_seen_messages([message])
 
     assert alice != bob
     assert repr(alice)
-    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.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 alice.self_contact
-    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()
+    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()
 
-    group = await alice.create_group("test group")
-    await group.add_contact(alice_contact_bob)
-    group_msg = await group.send_message(text="hello")
+    # 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 = 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)
-    await alice.delete_messages([group_msg])
+    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 await alice.get_blocked_contacts()
-    await alice_contact_bob.block()
-    blocked_contacts = await alice.get_blocked_contacts()
+    assert not alice.get_blocked_contacts()
+    alice_contact_bob.block()
+    blocked_contacts = alice.get_blocked_contacts()
     assert blocked_contacts
     assert blocked_contacts[0].contact == alice_contact_bob
 
-    await bob.remove()
-    await alice.stop_io()
+    bob.remove()
+    alice.stop_io()
 
 
-@pytest.mark.asyncio()
-async def test_chat(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_chat(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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!")
+    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!")
 
     while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
     message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
     bob_chat_alice = bob.get_chat_by_id(chat_id)
 
     assert alice_chat_bob != bob_chat_alice
     assert repr(alice_chat_bob)
-    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()
+    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()
     with pytest.raises(JsonRpcError):  # can't set name for 1:1 chats
-        await bob_chat_alice.set_name("test")
-    await bob_chat_alice.set_ephemeral_timer(300)
-    await bob_chat_alice.get_encryption_info()
+        bob_chat_alice.set_name("test")
+    bob_chat_alice.set_ephemeral_timer(300)
+    bob_chat_alice.get_encryption_info()
 
-    group = await alice.create_group("test group")
-    await group.add_contact(alice_contact_bob)
-    await group.get_qr_code()
+    group = alice.create_group("test group")
+    group.add_contact(alice_contact_bob)
+    group.get_qr_code()
 
-    snapshot = await group.get_basic_snapshot()
+    snapshot = group.get_basic_snapshot()
     assert snapshot.name == "test group"
-    await group.set_name("new name")
-    snapshot = await group.get_full_snapshot()
+    group.set_name("new name")
+    snapshot = group.get_full_snapshot()
     assert snapshot.name == "new name"
 
-    msg = await group.send_message(text="hi")
-    assert (await msg.get_snapshot()).text == "hi"
-    await group.forward_messages([msg])
+    msg = group.send_message(text="hi")
+    assert (msg.get_snapshot()).text == "hi"
+    group.forward_messages([msg])
 
-    await group.set_draft(text="test draft")
-    draft = await group.get_draft()
+    group.set_draft(text="test draft")
+    draft = group.get_draft()
     assert draft.text == "test draft"
-    await group.remove_draft()
-    assert not await group.get_draft()
+    group.remove_draft()
+    assert not group.get_draft()
 
-    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()
+    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()
 
 
-@pytest.mark.asyncio()
-async def test_contact(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_contact(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
 
     assert alice_contact_bob == alice.get_contact_by_id(alice_contact_bob.id)
     assert repr(alice_contact_bob)
-    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()
+    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()
     assert snapshot.address == bob_addr
-    await alice_contact_bob.create_chat()
+    alice_contact_bob.create_chat()
 
 
-@pytest.mark.asyncio()
-async def test_message(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_message(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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!")
+    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!")
 
     while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
     message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = 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
-        await snapshot.chat.send_text("hi")
-    await snapshot.chat.accept()
-    await snapshot.chat.send_text("hi")
+        snapshot.chat.send_text("hi")
+    snapshot.chat.accept()
+    snapshot.chat.send_text("hi")
 
-    await message.mark_seen()
-    await message.send_reaction("😎")
+    message.mark_seen()
+    message.send_reaction("😎")
+    reactions = message.get_reactions()
+    assert reactions
+    snapshot = message.get_snapshot()
+    assert reactions == snapshot.reactions
 
 
-@pytest.mark.asyncio()
-async def test_bot(acfactory) -> None:
+def test_is_bot(acfactory) -> None:
+    """Test that we can recognize messages submitted by bots."""
+    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 becomes a bot.
+    alice.set_config("bot", "1")
+    alice_chat_bob.send_text("Hello!")
+
+    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 = (await acfactory.get_online_accounts(1))[0]
-    bot = await acfactory.new_configured_bot()
+    user = (acfactory.get_online_accounts(1))[0]
+    bot = acfactory.new_configured_bot()
+    bot2 = acfactory.new_configured_bot()
 
-    assert await bot.is_configured()
-    assert await bot.account.get_config("bot") == "1"
+    assert bot.is_configured()
+    assert bot.account.get_config("bot") == "1"
 
-    hook = lambda e: mock.hook(e.msg_id), events.RawEvent(EventType.INCOMING_MSG)
+    hook = lambda e: mock.hook(e.msg_id) and None, events.RawEvent(EventType.INCOMING_MSG)
     bot.add_hook(*hook)
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
+    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)
 
@@ -248,15 +299,93 @@ async def test_bot(acfactory) -> None:
     hook = track, events.NewMessage(r"hello")
     bot.add_hook(*hook)
     bot.add_hook(track, events.NewMessage(command="/help"))
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="hello")
     mock.hook.assert_called_with(event.msg_id)
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello!")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="hello!")
     mock.hook.assert_called_with(event.msg_id)
-    await acfactory.process_message(from_account=user, to_client=bot, text="hey!")
+    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()
-    await acfactory.process_message(from_account=user, to_client=bot, text="hello")
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="/help")
+    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
+
+
+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)
+
+    while True:
+        event = alice.wait_for_event()
+        if event["kind"] == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            return

deltachat-rpc-client/tests/test_webxdc.py

@@ -1,25 +1,22 @@
-import pytest
-
 from deltachat_rpc_client import EventType
 
 
-@pytest.mark.asyncio()
-async def test_webxdc(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_webxdc(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")
+    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 = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        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 = await message.get_webxdc_info()
+    webxdc_info = message.get_webxdc_info()
     assert webxdc_info == {
         "document": None,
         "icon": "icon.png",
@@ -29,20 +26,20 @@ async def test_webxdc(acfactory) -> None:
         "summary": None,
     }
 
-    status_updates = await message.get_webxdc_status_updates()
+    status_updates = message.get_webxdc_status_updates()
     assert status_updates == []
 
-    await bob_chat_alice.accept()
-    await message.send_webxdc_status_update({"payload": 42}, "")
-    await message.send_webxdc_status_update({"payload": "Second update"}, "description")
+    bob_chat_alice.accept()
+    message.send_webxdc_status_update({"payload": 42}, "")
+    message.send_webxdc_status_update({"payload": "Second update"}, "description")
 
-    status_updates = await message.get_webxdc_status_updates()
+    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 = await message.get_webxdc_status_updates(1)
+    status_updates = message.get_webxdc_status_updates(1)
     assert status_updates == [
         {"payload": "Second update", "serial": 2, "max_serial": 2},
     ]

deltachat-rpc-client/tox.ini

@@ -6,17 +6,16 @@ envlist =
 
 [testenv]
 commands =
-    pytest {posargs}
+    pytest -n6 {posargs}
 setenv =
 # Avoid stack overflow when Rust core is built without optimizations.
     RUST_MIN_STACK=8388608
 passenv =
-    DCC_NEW_TMP_EMAIL
+    CHATMAIL_DOMAIN
 deps =
     pytest
-    pytest-asyncio
-    aiohttp
-    aiodns
+    pytest-timeout
+    pytest-xdist
 
 [testenv:lint]
 skipsdist = True
@@ -25,5 +24,10 @@ deps =
     ruff
     black
 commands =
-    black --check src/ examples/ tests/
+    black --quiet --check --diff src/ examples/ tests/
     ruff src/ examples/ tests/
+
+[pytest]
+timeout = 300
+log_cli = true
+log_level = info

deltachat-rpc-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.107.0"
+version = "1.127.2"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -9,17 +9,20 @@ 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" }
+deltachat-jsonrpc = { path = "../deltachat-jsonrpc", default-features = false }
+deltachat = { path = "..", default-features = false }
 
 anyhow = "1"
 env_logger = { version = "0.10.0" }
-futures-lite = "1.12.0"
+futures-lite = "2.0.0"
 log = "0.4"
-serde_json = "1.0.91"
+serde_json = "1.0.105"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.23.1", features = ["io-std"] }
-yerpc = { version = "0.3.1", features = ["anyhow_expose"] }
+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"]

deltachat-rpc-server/README.md

@@ -0,0 +1,37 @@
+# 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

@@ -1,68 +0,0 @@
-///! 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

@@ -0,0 +1,151 @@
+//! 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

@@ -8,5 +8,5 @@ license = "MPL-2.0"
 proc-macro = true
 
 [dependencies]
-syn = "1"
+syn = "2"
 quote = "1"

deltachat_derive/src/lib.rs

@@ -5,7 +5,7 @@ use quote::quote;
 
 use crate::proc_macro::TokenStream;
 
-// For now, assume (not check) that these macroses are applied to enum without
+// For now, assume (not check) that these macros are applied to enum without
 // data.  If this assumption is violated, compiler error will point to
 // generated code, which is not very user-friendly.
 

deny.toml

@@ -0,0 +1,89 @@
+[advisories]
+unmaintained = "allow"
+ignore = [
+    "RUSTSEC-2020-0071",
+    "RUSTSEC-2022-0093",
+]
+
+[bans]
+# Accept some duplicate versions, ideally we work towards this list
+# becoming empty.  Adding versions forces us to revisit this at least
+# when upgrading.
+# Please keep this list alphabetically sorted.
+skip = [
+     { name = "async-channel", version = "1.9.0" },
+     { name = "base16ct", version = "0.1.1" },
+     { name = "base64", version = "<0.21" },
+     { name = "bitflags", version = "1.3.2" },
+     { name = "block-buffer", version = "<0.10" },
+     { name = "convert_case", version = "0.4.0" },
+     { name = "curve25519-dalek", version = "3.2.0" },
+     { name = "darling_core", version = "<0.14" },
+     { name = "darling_macro", version = "<0.14" },
+     { name = "darling", version = "<0.14" },
+     { name = "der", version = "0.6.1" },
+     { name = "digest", version = "<0.10" },
+     { name = "ed25519-dalek", version = "1.0.1" },
+     { name = "ed25519", version = "1.5.3" },
+     { name = "event-listener", version = "2.5.3" },
+     { name = "getrandom", version = "<0.2" },
+     { name = "hashbrown", version = "<0.14.0" },
+     { name = "indexmap", version = "<2.0.0" },
+     { name = "pem-rfc7468", version = "0.6.0" },
+     { name = "pkcs8", version = "0.9.0" },
+     { name = "quick-error", version = "<2.0" },
+     { name = "rand_chacha", version = "<0.3" },
+     { name = "rand_core", version = "<0.6" },
+     { name = "rand", version = "<0.8" },
+     { name = "redox_syscall", version = "0.2.16" },
+     { name = "regex-automata", version = "0.1.10" },
+     { name = "ring", version = "0.16.20" },
+     { name = "regex-syntax", version = "0.6.29" },
+     { name = "sec1", version = "0.3.0" },
+     { name = "sha2", version = "<0.10" },
+     { name = "signature", version = "1.6.4" },
+     { name = "socket2", version = "0.4.9" },
+     { name = "spin", version = "<0.9.6" },
+     { name = "spki", version = "0.6.0" },
+     { name = "syn", version = "1.0.109" },
+     { name = "time", version = "<0.3" },
+     { name = "untrusted", version = "0.7.1" },
+     { name = "wasi", version = "<0.11" },
+     { name = "windows_aarch64_msvc", version = "<0.48" },
+     { name = "windows_i686_gnu", version = "<0.48" },
+     { name = "windows_i686_msvc", version = "<0.48" },
+     { name = "windows", version = "0.32.0" },
+     { name = "windows_x86_64_gnu", version = "<0.48" },
+     { name = "windows_x86_64_msvc", version = "<0.48" },
+]
+
+
+[licenses]
+allow = [
+    "0BSD",
+    "Apache-2.0",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "BSL-1.0", # Boost Software License 1.0
+    "CC0-1.0",
+    "ISC",
+    "MIT",
+    "MPL-2.0",
+    "OpenSSL",
+    "Unicode-DFS-2016",
+    "Zlib",
+]
+
+[[licenses.clarify]]
+name = "ring"
+expression = "MIT AND ISC AND OpenSSL"
+license-files = [
+      { path = "LICENSE", hash = 0xbd0eed23 },
+]
+
+[sources.allow-org]
+# Organisations which we allow git sources from.
+github = [
+       "async-email",
+       "deltachat",
+]

draft/aeap-mvp.md

@@ -57,7 +57,7 @@ Note that usually a mail is signed by a key that has a UID matching the from add
 ### Notes:
   
 - We treat protected and non-protected chats the same
-- We leave the aeap transition statement away since it seems not to be needed, makes things harder on the sending side, wastes some network traffic, and is worse for privacy (since more pepole know what old addresses you had).
+- We leave the aeap transition statement away since it seems not to be needed, makes things harder on the sending side, wastes some network traffic, and is worse for privacy (since more people know what old addresses you had).
 - As soon as we encrypt read receipts, sending a read receipt will be enough to tell a lot of people that you transitioned
 - AEAP will make the problem of inconsistent group state worse, both because it doesn't work if the message is unencrypted (even if the design allowed it, it would be problematic security-wise) and because some chat partners may have gotten the transition and some not. We should do something against this at some point in the future, like asking the user whether they want to add/remove the members to restore consistent group state.
 
@@ -66,13 +66,13 @@ Note that usually a mail is signed by a key that has a UID matching the from add
 
 #### Upsides:
 - With this approach, it's easy to switch to a model where the info about the transition is encoded in the PGP key. Since the key is gossiped, the information about the transition will spread virally.
-- Faster transation: If you send a message to e.g. "Delta Chat Dev", all members of the "sub-group" "delta android" will know of your transition.
+- Faster transition: If you send a message to e.g. "Delta Chat Dev", all members of the "sub-group" "delta android" will know of your transition.
 
 ### Alternatives and old discussions/plans:
 
 - Change the contact instead of rewriting the group member lists. This seems to call for more trouble since we will end up with multiple contacts having the same email address.
 
-- If needed, we could add a header a) indicating that the sender did an address transition or b) listing all the secondary (old) addresses.  For now, there is no big enough benefit to warrant introducing another header and its processing on the receiver side (including all the neccessary checks and handling of error cases). Instead, we only check for the `Chat-Version` header to prevent accidental transitions when an MUA user sends a message from another email address with the same key.
+- If needed, we could add a header a) indicating that the sender did an address transition or b) listing all the secondary (old) addresses.  For now, there is no big enough benefit to warrant introducing another header and its processing on the receiver side (including all the necessary checks and handling of error cases). Instead, we only check for the `Chat-Version` header to prevent accidental transitions when an MUA user sends a message from another email address with the same key.
 
 - The condition for a transition temporarily was:
 
@@ -107,8 +107,8 @@ The most obvious alternative would be to create a new contact with the new addre
 
 #### Upsides:
 - With this approach, it's easier to switch to a model where the info about the transition is encoded in the PGP key. Since the key is gossiped, the information about the transition will spread virally.
-- (Also, less important: Slightly faster transation: If you send a message to e.g. "Delta Chat Dev", all members of the "sub-group" "delta android" will know of your transition.)
-- It's easier to implement (if too many problems turn up, we can still switch to another approach and didn't wast that much development time.)
+- (Also, less important: Slightly faster transition: If you send a message to e.g. "Delta Chat Dev", all members of the "sub-group" "delta android" will know of your transition.)
+- It's easier to implement (if too many problems turn up, we can still switch to another approach and didn't waste that much development time.)
 
 [full messages](https://github.com/deltachat/deltachat-core-rust/pull/2896#discussion_r852002161)
   
@@ -124,4 +124,4 @@ Other
 Notes during implementing
 ========================
 
-- As far as I understand the code, unencrypted messages are unsigned. So, the transition only works if both sides have the other side's key.
+- As far as I understand the code, unencrypted messages are unsigned. So, the transition only works if both sides have the other side's key.

draft/msgwork_new_imap_jobs.rst

@@ -62,5 +62,5 @@ Notes/Questions:
 
   and design such that we can cover all imap flags.
 
-- It might not be neccessary to keep needs_send_mdn state in this table
+- It might not be necessary to keep needs_send_mdn state in this table
   if this can be decided rather when we succeed with mark_seen/mark_delete.

examples/simple.rs

@@ -1,100 +0,0 @@
-use deltachat::chat::{self, ChatId};
-use deltachat::chatlist::*;
-use deltachat::config;
-use deltachat::contact::*;
-use deltachat::context::*;
-use deltachat::message::Message;
-use deltachat::stock_str::StockStrings;
-use deltachat::{EventType, Events};
-use tempfile::tempdir;
-
-fn cb(event: EventType) {
-    match event {
-        EventType::ConfigureProgress { progress, .. } => {
-            log::info!("progress: {}", progress);
-        }
-        EventType::Info(msg) => {
-            log::info!("{}", msg);
-        }
-        EventType::Warning(msg) => {
-            log::warn!("{}", msg);
-        }
-        EventType::Error(msg) => {
-            log::error!("{}", msg);
-        }
-        event => {
-            log::info!("{:?}", event);
-        }
-    }
-}
-
-/// Run with `RUST_LOG=simple=info cargo run --release --example simple --features repl -- email pw`.
-#[tokio::main]
-async fn main() {
-    pretty_env_logger::try_init_timed().ok();
-
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    log::info!("creating database {:?}", dbfile);
-    let ctx = Context::new(&dbfile, 0, Events::new(), StockStrings::new())
-        .await
-        .expect("Failed to create context");
-    let info = ctx.get_info().await;
-    log::info!("info: {:#?}", info);
-
-    let events = ctx.get_event_emitter();
-    let events_spawn = tokio::task::spawn(async move {
-        while let Some(event) = events.recv().await {
-            cb(event.typ);
-        }
-    });
-
-    log::info!("configuring");
-    let args = std::env::args().collect::<Vec<String>>();
-    assert_eq!(args.len(), 3, "requires email password");
-    let email = args[1].clone();
-    let pw = args[2].clone();
-    ctx.set_config(config::Config::Addr, Some(&email))
-        .await
-        .unwrap();
-    ctx.set_config(config::Config::MailPw, Some(&pw))
-        .await
-        .unwrap();
-
-    ctx.configure().await.unwrap();
-
-    log::info!("------ RUN ------");
-    ctx.start_io().await;
-    log::info!("--- SENDING A MESSAGE ---");
-
-    let contact_id = Contact::create(&ctx, "dignifiedquire", "dignifiedquire@gmail.com")
-        .await
-        .unwrap();
-    let chat_id = ChatId::create_for_contact(&ctx, contact_id).await.unwrap();
-
-    for i in 0..1 {
-        log::info!("sending message {}", i);
-        chat::send_text_msg(&ctx, chat_id, format!("Hi, here is my {}nth message!", i))
-            .await
-            .unwrap();
-    }
-
-    // wait for the message to be sent out
-    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-
-    log::info!("fetching chats..");
-    let chats = Chatlist::try_load(&ctx, 0, None, None).await.unwrap();
-
-    for i in 0..chats.len() {
-        let msg = Message::load_from_db(&ctx, chats.get_msg_id(i).unwrap().unwrap())
-            .await
-            .unwrap();
-        log::info!("[{}] msg: {:?}", i, msg);
-    }
-
-    log::info!("stopping");
-    ctx.stop_io().await;
-    log::info!("closing");
-    drop(ctx);
-    events_spawn.await.unwrap();
-}

node/README.md

@@ -124,7 +124,7 @@ $ npm run test
 ```
 
 (when using [fnm](https://github.com/Schniz/fnm) instead of nvm, you can select the architecture)
-If your node and electron are already build for arm64 you can also try bulding for arm:
+If your node and electron are already build for arm64 you can also try building for arm:
 
 ```
 $ fnm install 16 --arch arm64
@@ -182,7 +182,7 @@ this example can also be found in the examples folder [examples/send_message.js]
 
 ### Generating Docs
 
-We are curently migrating to automaticaly generated documentation.
+We are currently migrating to automatically generated documentation.
 You can find the old documentation at [old_docs](./old_docs).
 
 to generate the documentation, run:
@@ -204,10 +204,10 @@ Running `npm test` ends with showing a code coverage report, which is produced b
 
 The coverage report from `nyc` in the console is rather limited. To get a more detailed coverage report you can run `npm run coverage-html-report`. This will produce a html report from the `nyc` data and display it in a browser on your local machine.
 
-To run the integration tests you need to set the `DCC_NEW_TMP_EMAIL` environment variables. E.g.:
+To run the integration tests you need to set the `CHATMAIL_DOMAIN` environment variables. E.g.:
 
 ```
-$ export DCC_NEW_TMP_EMAIL=https://testrun.org/new_email?t=[token]
+$ export CHATMAIL_DOMAIN=chat.example.org
 $ npm run test
 ```