try to reproduce (#4707)

Version 1.5.0 is yanked.

.gitattributes

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

.github/dependabot.yml

@@ -5,5 +5,5 @@ updates:
     schedule:
       interval: "monthly"
     commit-message:
-      prefix: "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,51 +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@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v3
+      - 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@v1
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --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@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-            toolchain: stable
-            components: clippy
-            override: true
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v1
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace --tests --examples --benches --features repl -- -D warnings
+      - uses: actions/checkout@v3
+      - name: Check provider database
+        run: scripts/update-provider-database.sh
 
   docs:
     name: Rust doc comments
@@ -54,110 +64,216 @@ jobs:
       RUSTDOCFLAGS: -Dwarnings
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v2
-      - name: Install rust stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          components: rust-docs
-          override: true
+        uses: actions/checkout@v3
       - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v1
+        uses: swatinem/rust-cache@v2
       - name: Rustdoc
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --document-private-items --no-deps
+        run: cargo doc --document-private-items --no-deps
 
-  build_and_test:
-    name: Build and test
+  rust_tests:
+    name: Rust tests
     strategy:
       matrix:
         include:
-          # Currently used Rust version, same as in `rust-toolchain` file.
           - os: ubuntu-latest
-            rust: 1.61.0
-            python: 3.9
+            rust: 1.73.0
           - os: windows-latest
-            rust: 1.61.0
-            python: false # Python bindings compilation on Windows is not supported.
+            rust: 1.73.0
+          - os: macos-latest
+            rust: 1.73.0
 
-          # Minimum Supported Rust Version = 1.57.0
-          #
-          # Minimum Supported Python Version = 3.7
-          # This is the minimum version for which manylinux Python wheels are
-          # built.
+          # Minimum Supported Rust Version = 1.70.0
           - os: ubuntu-latest
-            rust: 1.57.0
-            python: 3.7
+            rust: 1.70.0
     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: 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@v1
+      - name: Cache rust cargo artifacts
+        uses: swatinem/rust-cache@v2
 
-    - name: check
-      uses: actions-rs/cargo@v1
-      with:
-        command: check
-        args: --all --bins --examples --tests --features repl --benches
+      - name: Tests
+        env:
+          RUST_BACKTRACE: 1
+        run: cargo test --workspace
 
-    - name: tests
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --all
+      - name: Test cargo vendor
+        run: cargo vendor
 
-    - name: test cargo vendor
-      uses: actions-rs/cargo@v1
-      with:
-        command: vendor
+  c_library:
+    name: Build C library
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
 
-    - name: install python
-      if: ${{ matrix.python }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.python }}
+      - name: Cache rust cargo artifacts
+        uses: swatinem/rust-cache@v2
 
-    - name: install tox
-      if: ${{ matrix.python }}
-      run: pip install tox
+      - name: Build C library
+        run: cargo build -p deltachat_ffi --features jsonrpc
 
-    - name: build C library
-      if: ${{ matrix.python }}
-      uses: actions-rs/cargo@v1
-      with:
-        command: build
-        args: -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
 
-    - 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
+  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: install pypy
-      if: ${{ matrix.python }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: 'pypy${{ matrix.python }}'
+      - name: Cache rust cargo artifacts
+        uses: swatinem/rust-cache@v2
 
-    - 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: Build deltachat-rpc-server
+        run: cargo build -p deltachat-rpc-server
+
+      - name: Upload deltachat-rpc-server
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.os }}-deltachat-rpc-server
+          path: ${{ matrix.os == 'windows-latest' && 'target/debug/deltachat-rpc-server.exe' || 'target/debug/deltachat-rpc-server' }}
+          retention-days: 1
+
+  python_lint:
+    name: Python lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+
+      - name: Install tox
+        run: pip install tox
+
+      - name: Lint Python bindings
+        working-directory: python
+        run: tox -e lint
+
+      - name: Lint deltachat-rpc-client
+        working-directory: deltachat-rpc-client
+        run: tox -e lint
+
+  cffi_python_tests:
+    name: CFFI Python tests
+    needs: ["c_library", "python_lint"]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Currently used Rust version.
+          - os: ubuntu-latest
+            python: 3.12
+          - os: macos-latest
+            python: 3.12
+
+          # PyPy tests
+          - os: ubuntu-latest
+            python: pypy3.10
+          - os: macos-latest
+            python: pypy3.10
+
+          # Minimum Supported Python Version = 3.7
+          # This is the minimum version for which manylinux Python wheels are
+          # built. Test it with minimum supported Rust version.
+          - os: ubuntu-latest
+            python: 3.7
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Download libdeltachat.a
+        uses: actions/download-artifact@v3
+        with:
+          name: ${{ matrix.os }}-libdeltachat.a
+          path: target/debug
+
+      - name: Install python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Install tox
+        run: pip install tox
+
+      - 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
+
+  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
+
+          # PyPy tests
+          - os: ubuntu-latest
+            python: pypy3.10
+          - os: macos-latest
+            python: pypy3.10
+
+          # Minimum Supported Python Version = 3.7
+          - os: ubuntu-latest
+            python: 3.7
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Install tox
+        run: pip install tox
+
+      - name: Download deltachat-rpc-server
+        uses: actions/download-artifact@v3
+        with:
+          name: ${{ matrix.os }}-deltachat-rpc-server
+          path: target/debug
+
+      - name: Make deltachat-rpc-server executable
+        if: ${{ matrix.os != 'windows-latest' }}
+        run: chmod +x target/debug/deltachat-rpc-server
+
+      - name: Add deltachat-rpc-server to path
+        if: ${{ matrix.os != 'windows-latest' }}
+        run: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH
+
+      - 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@v2
-      - uses: actions/setup-node@v2
+        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,20 +37,19 @@ 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:tsc
+          npm run build
           npm pack .
           ls -lah
           mv $(find deltachat-jsonrpc-client-*) $DELTACHAT_JSONRPC_TAR_GZ
       - name: Upload Prebuild
-        uses: actions/upload-artifact@v1
+        uses: actions/upload-artifact@v3
         with:
           name: deltachat-jsonrpc-client.tgz
           path: deltachat-jsonrpc/typescript/${{ env.DELTACHAT_JSONRPC_TAR_GZ }}
@@ -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
@@ -14,33 +14,27 @@ jobs:
   build_and_test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Use Node.js 16.x
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
         with:
           node-version: 16.x
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
       - name: Add Rust cache
-        uses: Swatinem/rust-cache@v1.3.0
+        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 ::set-output name=prid::$PULLREQUEST_ID
-    - 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@v1
+      - uses: actions/checkout@v3
 
-    - name: Use Node.js 16.x
-      uses: actions/setup-node@v1
-      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@v2
-      - uses: actions/setup-node@v2
+        uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: '16'
+          node-version: "16"
       - name: System info
         run: |
           rustc -vV
@@ -29,7 +28,7 @@ jobs:
           node --version
 
       - name: Cache node modules
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ${{ env.APPDATA }}/npm-cache
@@ -37,7 +36,7 @@ jobs:
           key: ${{ matrix.os }}-node-${{ hashFiles('**/package.json') }}
 
       - name: Cache cargo index
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cargo/registry/
@@ -47,39 +46,109 @@ 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 .
 
       - name: Upload Prebuild
-        uses: actions/upload-artifact@v1
+        uses: actions/upload-artifact@v3
         with:
           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@v2
+        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,44 +166,44 @@ 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
-        uses: actions/upload-artifact@v1
+      - name: Upload prebuild
+        uses: actions/upload-artifact@v3
         with:
           name: deltachat-node.tgz
           path: ${{ env.DELTACHAT_NODE_TAR_GZ }}
@@ -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@v2
-      - uses: actions/setup-node@v2
+        uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: '16'
+          node-version: "16"
       - name: System info
         run: |
           rustc -vV
@@ -29,7 +37,7 @@ jobs:
           node --version
 
       - name: Cache node modules
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ${{ env.APPDATA }}/npm-cache
@@ -37,7 +45,7 @@ jobs:
           key: ${{ matrix.os }}-node-${{ hashFiles('**/package.json') }}
 
       - name: Cache cargo index
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cargo/registry/
@@ -47,23 +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 }}
-      - 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 }}
+          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,22 +12,13 @@ jobs:
     name: Build REPL example
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@master
+      - uses: actions/checkout@v3
 
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: 1.50.0
-        override: true
+      - name: Build
+        run: cargo build -p deltachat-repl --features vendored
 
-    - name: build
-      uses: actions-rs/cargo@v1
-      with:
-        command: build
-        args: --example repl --features repl,vendored
-
-    - name: Upload binary
-      uses: actions/upload-artifact@v2
-      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,26 +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@v1
-    - uses: actions-rs/toolchain@v1
-    - name: Build the documentation with cargo
-      run: |
-        cargo doc --package deltachat --no-deps
-    - name: Upload to rs.delta.chat
-      uses: up9cloud/action-rsync@v1.3
-      env:
-        USER: ${{ secrets.USERNAME }}
-        KEY: ${{ secrets.KEY }}
-        HOST: "delta.chat"
-        SOURCE: "target/doc"
-        TARGET: "/var/www/html/rs/"
-
+      - 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,28 +1,28 @@
+# GitHub Actions workflow
+# to build `deltachat_fii` crate documentation
+# and upload it to <https://cffi.delta.chat/>
+
 name: Build & Deploy Documentation on cffi.delta.chat
 
 on:
   push:
     branches:
-      - master
-      - docs-gh-action
+      - main
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v1
-    - uses: actions-rs/toolchain@v1
-    - name: Build the documentation with cargo
-      run: |
-        cargo doc --package deltachat_ffi --no-deps
-    - name: Upload to cffi.delta.chat
-      uses: up9cloud/action-rsync@v1.3
-      env:
-        USER: ${{ secrets.USERNAME }}
-        KEY: ${{ secrets.KEY }}
-        HOST: "delta.chat"
-        SOURCE: "target/doc"
-        TARGET: "/var/www/html/cffi/"
-
+      - 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
 *~
@@ -12,12 +13,15 @@ include
 *.db
 *.db-blobs
 
+.tox
 python/.eggs
-python/.tox
 *.egg-info
 __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,10 +1,9 @@
 [package]
 name = "deltachat"
-version = "1.102.0"
-authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
+version = "1.127.2"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.57"
+rust-version = "1.70"
 
 [profile.dev]
 debug = 0
@@ -14,105 +13,110 @@ 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.5", default-features = false, features = ["smtp-transport", "socks5", "runtime-tokio"] }
-trust-dns-resolver = "0.22"
-tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
-tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
+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.13"
-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.4", 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.13"
-native-tls = "0.2"
-num_cpus = "1.13"
-num-derive = "0.3"
+mailparse = "0.14"
+mime = "0.3.17"
+num_cpus = "1.16"
+num-derive = "0.4"
 num-traits = "0.2"
-once_cell = "1.16.0"
-percent-encoding = "2.2"
-pgp = { version = "0.9", default-features = false }
-pretty_env_logger = { version = "0.4", optional = true }
-quick-xml = "0.23"
-r2d2 = "0.8"
-r2d2_sqlite = "0.20"
+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.6"
-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"
+strum = "0.25"
+strum_macros = "0.25"
+tagger = "4.3.4"
+textwrap = "0.16.0"
 thiserror = "1"
-toml = "0.5"
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
+tokio-io-timeout = "1.2.0"
+tokio-stream = { version = "0.1.14", features = ["fs"] }
+tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
+tokio-util = "0.7.9"
+toml = "0.7"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }
-fast-socks5 = "0.8"
-humansize = "1"
-qrcodegen = "1.7.0"
-tagger = "4.3.3"
-textwrap = "0.16.0"
-async-channel = "1.6.1"
-futures-lite = "1.12.0"
-tokio-stream = { version = "0.1.11", features = ["fs"] }
-reqwest = { version = "0.11.12", features = ["json"] }
-async_zip = { version = "0.0.9", default-features = false, features = ["deflate"] }
 
 [dev-dependencies]
 ansi_term = "0.12.0"
-criterion = { version = "0.3.6", 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 = [
   "deltachat-ffi",
   "deltachat_derive",
   "deltachat-jsonrpc",
-  "deltachat-rpc-server"
+  "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
@@ -137,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
@@ -115,21 +132,55 @@ use the `--ignored` argument to the test binary (not to cargo itself):
 $ cargo test -- --ignored
 ```
 
+### Fuzzing
+
+Install [`cargo-bolero`](https://github.com/camshaft/bolero) with
+```sh
+$ cargo install cargo-bolero
+```
+
+Run fuzzing tests with
+```sh
+$ cd fuzz
+$ cargo bolero test fuzz_mailparse --release=false -s NONE
+```
+
+Corpus is created at `fuzz/fuzz_targets/corpus`,
+you can add initial inputs there.
+For `fuzz_mailparse` target corpus can be populated with
+`../test-data/message/*.eml`.
+
+To run with AFL instead of libFuzzer:
+```sh
+$ cargo bolero test fuzz_format_flowed --release=false -e afl -s NONE
+```
+
 ## Features
 
 - `vendored`: When using Openssl for TLS, this bundles a vendored version.
 - `nightly`: Enable nightly only performance and security related features.
 
+## Update Provider Data
+
+To add the updates from the
+[provider-db](https://github.com/deltachat/provider-db) to the core, run:
+
+```
+./src/provider/update.py ../provider-db/_providers/ > src/provider/data.rs
+```
+
 ## Language bindings and frontend projects
 
 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 ''`.

assets/icon-archive.svg

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

benches/contacts.rs

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

benches/create_account.rs

@@ -1,13 +1,15 @@
+use std::path::PathBuf;
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::accounts::Accounts;
-use std::path::PathBuf;
 use tempfile::tempdir;
 
 async fn create_accounts(n: u32) {
     let dir = tempdir().unwrap();
     let p: PathBuf = dir.path().join("accounts");
 
-    let 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

@@ -1,7 +1,6 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
 use deltachat::chat::{self, ChatId};
 use deltachat::chatlist::Chatlist;
 use deltachat::context::Context;
@@ -15,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/get_chatlist.rs

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

benches/receive_emails.rs

@@ -38,11 +38,64 @@ Hello {i}",
     context
 }
 
+/// Receive 100 emails that remove charlie@example.com and add
+/// him back
+async fn recv_groupmembership_emails(context: Context) -> Context {
+    for i in 0..50 {
+        let imf_raw = format!(
+            "Subject: Benchmark
+Message-ID: Gr.OssSYnOFkhR.{i}@testrun.org
+Date: Sat, 07 Dec 2019 19:00:27 +0000
+To: alice@example.com, b@example.com, c@example.com, d@example.com, e@example.com, f@example.com
+From: sender@testrun.org
+Chat-Version: 1.0
+Chat-Disposition-Notification-To: sender@testrun.org
+Chat-User-Avatar: 0
+Chat-Group-Member-Added: charlie@example.com
+In-Reply-To: Gr.OssSYnOFkhR.{i_dec}@testrun.org
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+
+Hello {i}",
+            i = i,
+            i_dec = i - 1,
+        );
+        receive_imf(&context, black_box(imf_raw.as_bytes()), false)
+            .await
+            .unwrap();
+
+        let imf_raw = format!(
+            "Subject: Benchmark
+Message-ID: Gr.OssSYnOFkhR.{i}@testrun.org
+Date: Sat, 07 Dec 2019 19:00:27 +0000
+To: alice@example.com, b@example.com, c@example.com, d@example.com, e@example.com, f@example.com
+From: sender@testrun.org
+Chat-Version: 1.0
+Chat-Disposition-Notification-To: sender@testrun.org
+Chat-User-Avatar: 0
+Chat-Group-Member-Removed: charlie@example.com
+In-Reply-To: Gr.OssSYnOFkhR.{i_dec}@testrun.org
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+
+Hello {i}",
+            i = i,
+            i_dec = i - 1,
+        );
+        receive_imf(&context, black_box(imf_raw.as_bytes()), false)
+            .await
+            .unwrap();
+    }
+    context
+}
+
 async fn create_context() -> Context {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
     let id = 100;
-    let context = Context::new(&dbfile, id, Events::new(), StockStrings::new())
+    let context = Context::new(dbfile.as_path(), id, Events::new(), StockStrings::new())
         .await
         .unwrap();
 
@@ -52,7 +105,7 @@ async fn create_context() -> Context {
 
     if backup.exists() {
         println!("Importing backup");
-        imex(&context, ImexMode::ImportBackup, &backup, None)
+        imex(&context, ImexMode::ImportBackup, backup.as_path(), None)
             .await
             .unwrap();
     }
@@ -83,6 +136,20 @@ fn criterion_benchmark(c: &mut Criterion) {
             }
         });
     });
+    group.bench_function(
+        "Receive 100 Chat-Group-Member-{Added|Removed} messages",
+        |b| {
+            let rt = tokio::runtime::Runtime::new().unwrap();
+            let context = rt.block_on(create_context());
+
+            b.to_async(&rt).iter(|| {
+                let ctx = context.clone();
+                async move {
+                    recv_groupmembership_emails(black_box(ctx)).await;
+                }
+            });
+        },
+    );
     group.finish();
 }
 

benches/search_msgs.rs

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

benches/send_events.rs

@@ -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,8 +1,7 @@
 [package]
 name = "deltachat_ffi"
-version = "1.102.0"
+version = "1.127.2"
 description = "Deltachat FFI"
-authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 readme = "README.md"
 license = "MPL-2.0"
@@ -18,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.16.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.
@@ -1227,7 +1339,11 @@ int             dc_get_msg_cnt               (dc_context_t* context, uint32_t ch
  * Get the number of _fresh_ messages in a chat.
  * Typically used to implement a badge with a number in the chatlist.
  *
- * If the specified chat is muted,
+ * As muted archived chats are not unarchived automatically,
+ * a similar information is needed for the @ref dc_get_chatlist() "archive link" as well:
+ * here, the number of archived chats containing fresh messages is returned.
+ *
+ * If the specified chat is muted or the @ref dc_get_chatlist() "archive link",
  * the UI should show the badge counter "less obtrusive",
  * e.g. using "gray" instead of "red" color.
  *
@@ -1239,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
@@ -1278,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
@@ -1320,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.
@@ -1338,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.
  *
@@ -1549,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.
@@ -1877,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
@@ -2096,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`
@@ -2105,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
@@ -2119,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,
@@ -2291,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
@@ -2316,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().
  *
@@ -2336,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().
@@ -2626,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
  *
@@ -2668,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);
 
 
 /**
@@ -3180,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.
@@ -3454,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.
@@ -3463,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().
@@ -3667,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().
@@ -3720,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().
  */
@@ -3737,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);
 
@@ -4057,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,
@@ -4323,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`.
@@ -4735,6 +5046,43 @@ int             dc_contact_is_blocked        (const dc_contact_t* contact);
 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.
+ * 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.
+ * @return 
+ *    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);
+
+
+/**
+ * Return the `ContactId` that verified a contact
+ *
+ * The UI may use this in addition to a checkmark showing the verification status
+ *
+ * @memberof dc_contact_t
+ * @param contact The contact object.
+ * @return 
+ *    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.
+ */
+uint32_t       dc_contact_get_verifier_id      (dc_contact_t* contact);
+
+
 /**
  * @class dc_provider_t
  *
@@ -4828,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
  *
@@ -5305,7 +5719,6 @@ void            dc_reactions_unref       (dc_reactions_t* reactions);
  */
 
 
-
 /**
  * @class dc_jsonrpc_instance_t
  *
@@ -5354,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
  *
@@ -5542,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
  *
@@ -5636,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.
@@ -5693,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.
@@ -5776,7 +6217,7 @@ void dc_event_unref(dc_event_t* event);
  * @param data2 (int) The progress as:
  *     300=vg-/vc-request received, typically shown as "bob@addr joins".
  *     600=vg-/vc-request-with-auth received, vg-member-added/vc-contact-confirm sent, typically shown as "bob@addr verified".
- *     800=vg-member-added-received received, shown as "bob@addr securely joined GROUP", only sent for the verified-group-protocol.
+ *     800=contact added to chat, shown as "bob@addr securely joined GROUP". Only for the verified-group-protocol.
  *     1000=Protocol finished for this contact.
  */
 #define DC_EVENT_SECUREJOIN_INVITER_PROGRESS      2060
@@ -5871,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
 
 
 /**
@@ -6294,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."
@@ -6354,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.
@@ -6576,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
@@ -6807,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

@@ -1,10 +1,12 @@
 //! # Legacy generic return values for C API.
 
+use std::borrow::Cow;
+
+use anyhow::Error;
+
 use crate::message::MessageState;
 use crate::qr::Qr;
 use crate::summary::{Summary, SummaryPrefix};
-use anyhow::Error;
-use std::borrow::Cow;
 
 /// An object containing a set of values.
 /// The meaning of the values is defined by the function returning the object.
@@ -12,6 +14,8 @@ use std::borrow::Cow;
 /// 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),
@@ -20,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 {
@@ -50,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),
@@ -101,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,
@@ -125,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(),
@@ -149,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
@@ -173,6 +175,8 @@ pub enum LotState {
     /// text1=domain
     QrAccount = 250,
 
+    QrBackup = 251,
+
     /// text1=domain, text2=instance pattern
     QrWebrtcInstance = 260,
 
@@ -213,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-ffi/src/string.rs

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

deltachat-jsonrpc/.gitignore

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

deltachat-jsonrpc/Cargo.toml

@@ -1,8 +1,7 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.102.0"
+version = "1.127.2"
 description = "DeltaChat JSON-RPC API"
-authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
 license = "MPL-2.0"
@@ -16,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.6.1" }
-futures = { version = "0.3.25" }
-serde_json = "1.0.87"
-yerpc = { version = "^0.3.1", features = ["anyhow_expose"] }
-typescript-type-def = { version = "0.5.3", features = ["json_value"] }
-tokio = { version = "1.21.2" }
-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.5.17", optional = true, features = ["ws"] }
-env_logger = { version = "0.9.1", optional = true }
+axum = { version = "0.6.20", optional = true, features = ["ws"] }
+env_logger = { version = "0.10.0", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.21.2", 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

@@ -1,51 +1,53 @@
-use anyhow::{anyhow, bail, ensure, Context, Result};
-use deltachat::{
-    chat::{
-        self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, marknoticed_chat,
-        remove_contact_from_chat, Chat, ChatId, ChatItem, ProtectionStatus,
-    },
-    chatlist::Chatlist,
-    config::Config,
-    constants::DC_MSG_ID_DAYMARKER,
-    contact::{may_be_valid_addr, Contact, ContactId, Origin},
-    context::get_info,
-    ephemeral::Timer,
-    imex, location,
-    message::{
-        self, delete_msgs, get_msg_info, markseen_msgs, Message, MessageState, MsgId, Viewtype,
-    },
-    provider::get_provider_info,
-    qr,
-    qr_code_generator::get_securejoin_qr_svg,
-    reaction::send_reaction,
-    securejoin,
-    stock_str::StockMessage,
-    webxdc::StatusUpdateSerial,
-};
-use sanitize_filename::is_sanitized;
 use std::collections::BTreeMap;
 use std::sync::Arc;
 use std::{collections::HashMap, str::FromStr};
-use tokio::{fs, sync::RwLock};
+
+use anyhow::{anyhow, bail, ensure, Context, Result};
+pub use deltachat::accounts::Accounts;
+use deltachat::chat::{
+    self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, get_chat_msgs_ex,
+    marknoticed_chat, remove_contact_from_chat, Chat, ChatId, ChatItem, MessageListOptions,
+    ProtectionStatus,
+};
+use deltachat::chatlist::Chatlist;
+use deltachat::config::Config;
+use deltachat::constants::DC_MSG_ID_DAYMARKER;
+use deltachat::contact::{may_be_valid_addr, Contact, ContactId, Origin};
+use deltachat::context::get_info;
+use deltachat::ephemeral::Timer;
+use deltachat::imex;
+use deltachat::location;
+use deltachat::message::get_msg_read_receipts;
+use deltachat::message::{
+    self, delete_msgs, markseen_msgs, Message, MessageState, MsgId, Viewtype,
+};
+use deltachat::provider::get_provider_info;
+use deltachat::qr::{self, Qr};
+use deltachat::qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg};
+use deltachat::reaction::{get_msg_reactions, send_reaction};
+use deltachat::securejoin;
+use deltachat::stock_str::StockMessage;
+use deltachat::webxdc::StatusUpdateSerial;
+use sanitize_filename::is_sanitized;
+use tokio::fs;
+use tokio::sync::{watch, Mutex, RwLock};
 use walkdir::WalkDir;
 use yerpc::rpc;
 
-pub use deltachat::accounts::Accounts;
-
-pub mod events;
 pub mod types;
 
-use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
-use crate::api::types::qr::QrObject;
-
+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,
@@ -53,24 +55,48 @@ use self::types::{
         JSONRPCMessageListItem, MessageNotificationInfo, MessageSearchResult, MessageViewtype,
     },
 };
+use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
+use crate::api::types::qr::QrObject;
 
-use num_traits::FromPrimitive;
+#[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> {
@@ -82,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
     // ---------------------------------------------
@@ -109,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> {
@@ -135,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(())
@@ -156,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(())
     }
@@ -230,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,
@@ -244,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(())
     }
@@ -266,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
@@ -383,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
@@ -426,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,
@@ -435,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:#}"),
                     },
                 },
             );
@@ -677,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)
@@ -733,7 +859,7 @@ impl CommandApi {
         image_path: Option<String>,
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
-        chat::set_chat_profile_image(&ctx, ChatId::new(chat_id), image_path.unwrap_or_default())
+        chat::set_chat_profile_image(&ctx, ChatId::new(chat_id), &image_path.unwrap_or_default())
             .await
     }
 
@@ -779,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())
@@ -805,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 {
@@ -874,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 {
@@ -898,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())
@@ -918,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)
@@ -959,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.
@@ -979,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,
@@ -1162,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(())
@@ -1236,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,
@@ -1286,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(
@@ -1314,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
     // ---------------------------------------------
@@ -1424,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,
@@ -1441,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,
@@ -1452,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())
     }
@@ -1473,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
@@ -1521,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,
@@ -1614,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())
@@ -1637,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);
         }
@@ -1676,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);
         }
@@ -1704,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)
@@ -1716,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?;
@@ -1738,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,35 +45,40 @@ pub enum ChatListItemFetchResult {
         /// contact id if this is a dm chat (for view profile entry in context menu)
         dm_chat_contact: Option<u32>,
         was_seen_recently: bool,
+        last_message_type: Option<MessageViewtype>,
+        last_message_id: Option<u32>,
     },
-    ArchiveLink,
     #[serde(rename_all = "camelCase")]
-    Error {
-        id: u32,
-        error: String,
-    },
+    ArchiveLink { fresh_message_counter: usize },
+    #[serde(rename_all = "camelCase")]
+    Error { id: u32, error: String },
 }
 
 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() {
-        return Ok(ChatListItemFetchResult::ArchiveLink);
+        return Ok(ChatListItemFetchResult::ArchiveLink {
+            fresh_message_counter,
+        });
     }
 
-    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
@@ -83,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?;
@@ -98,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,
         };
@@ -111,7 +118,6 @@ pub(crate) async fn get_chat_list_item_by_id(
         (None, false)
     };
 
-    let fresh_message_counter = chat_id.get_fresh_msg_cnt(ctx).await?;
     let color = color_int_to_hex_string(chat.get_color(ctx).await?);
 
     Ok(ChatListItemFetchResult::ChatListItem {
@@ -123,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,
@@ -137,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,
@@ -20,6 +20,10 @@ pub struct ContactObject {
     name_and_addr: String,
     is_blocked: bool,
     is_verified: bool,
+    /// the address that verified this contact
+    verifier_addr: Option<String>,
+    /// the id of the contact that verified this contact
+    verifier_id: Option<u32>,
     /// the contact's last seen timestamp
     last_seen: i64,
     was_seen_recently: bool,
@@ -36,6 +40,18 @@ impl ContactObject {
         };
         let is_verified = contact.is_verified(context).await? == VerifiedStatus::BidirectVerified;
 
+        let (verifier_addr, verifier_id) = if is_verified {
+            (
+                contact.get_verifier_addr(context).await?,
+                contact
+                    .get_verifier_id(context)
+                    .await?
+                    .map(|contact_id| contact_id.to_u32()),
+            )
+        } else {
+            (None, None)
+        };
+
         Ok(ContactObject {
             address: contact.get_addr().to_owned(),
             color: color_int_to_hex_string(contact.get_color()),
@@ -48,6 +64,8 @@ impl ContactObject {
             name_and_addr: contact.get_name_n_addr(),
             is_blocked: contact.is_blocked(),
             is_verified,
+            verifier_addr,
+            verifier_id,
             last_seen: contact.last_seen(),
             was_seen_recently: contact.was_seen_recently(),
         })

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,12 +34,15 @@ pub struct MessageObject {
     quote: Option<MessageQuote>,
     parent_id: Option<u32>,
 
-    text: Option<String>,
+    text: String,
     has_location: bool,
     has_html: bool,
     view_type: MessageViewtype,
     state: u32,
 
+    /// An error text, if there is one.
+    error: Option<String>,
+
     timestamp: i64,
     sort_timestamp: i64,
     received_timestamp: i64,
@@ -45,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,
 
@@ -72,7 +85,7 @@ pub struct MessageObject {
     reactions: Option<JSONRPCReactions>,
 }
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(tag = "kind")]
 enum MessageQuote {
     JustText {
@@ -100,9 +113,13 @@ 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 file_bytes = message.get_filebytes(context).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();
 
         let webxdc_info = if message.get_viewtype() == Viewtype::Webxdc {
@@ -118,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(),
@@ -146,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 {
@@ -166,7 +187,8 @@ 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(),
             sort_timestamp: message.get_sort_timestamp(),
@@ -178,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(),
@@ -187,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,
             },
@@ -214,7 +237,7 @@ impl MessageObject {
     }
 }
 
-#[derive(Serialize, Deserialize, TypeDef)]
+#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Viewtype")]
 pub enum MessageViewtype {
     Unknown,
@@ -290,11 +313,12 @@ impl From<MessageViewtype> for Viewtype {
     }
 }
 
-#[derive(Serialize, TypeDef)]
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
 pub enum DownloadState {
     Done,
     Available,
     Failure,
+    Undecipherable,
     InProgress,
 }
 
@@ -304,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,
@@ -364,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,
@@ -422,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,
 }
@@ -438,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 {
@@ -486,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,22 +1,23 @@
 pub mod api;
-pub use api::events;
 pub use yerpc;
 
 #[cfg(test)]
 mod tests {
-    use super::api::{Accounts, CommandApi};
     use async_channel::unbounded;
     use futures::StreamExt;
     use tempfile::TempDir;
     use yerpc::{RpcClient, RpcSession};
 
+    use super::api::{Accounts, CommandApi};
+
     #[tokio::test(flavor = "multi_thread")]
     async fn basic_json_rpc_functionality() -> anyhow::Result<()> {
         let tmp_dir = TempDir::new().unwrap().path().into();
-        let 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);
@@ -35,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(())
@@ -54,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);
@@ -76,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

@@ -1,11 +1,11 @@
-use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use std::net::SocketAddr;
 use std::path::PathBuf;
+
+use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use yerpc::axum::handle_ws_rpc;
 use yerpc::{RpcClient, RpcSession};
 
 mod api;
-use api::events::event_to_json_rpc_notification;
 use api::{Accounts, CommandApi};
 
 const DEFAULT_PORT: u16 = 20808;
@@ -19,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()
@@ -43,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/.gitignore

@@ -6,3 +6,4 @@ yarn.lock
 package-lock.json
 docs
 accounts
+generated

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/generated/client.ts

@@ -1,948 +0,0 @@
-// AUTO-GENERATED by yerpc-derive
-
-import * as T from "./types.js"
-import * as RPC from "./jsonrpc.js"
-
-type RequestMethod = (method: string, params?: RPC.Params) => Promise<unknown>;
-type NotificationMethod = (method: string, params?: RPC.Params) => void;
-
-interface Transport {
-  request: RequestMethod,
-  notification: NotificationMethod
-}
-
-export class RawClient {
-  constructor(private _transport: Transport) {}
-
-  /**
-   * Check if an email address is valid.
-   */
-  public checkEmailValidity(email: string): Promise<boolean> {
-    return (this._transport.request('check_email_validity', [email] as RPC.Params)) as Promise<boolean>;
-  }
-
-  /**
-   * Get general system info.
-   */
-  public getSystemInfo(): Promise<Record<string,string>> {
-    return (this._transport.request('get_system_info', [] as RPC.Params)) as Promise<Record<string,string>>;
-  }
-
-
-  public addAccount(): Promise<T.U32> {
-    return (this._transport.request('add_account', [] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public removeAccount(accountId: T.U32): Promise<null> {
-    return (this._transport.request('remove_account', [accountId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getAllAccountIds(): Promise<(T.U32)[]> {
-    return (this._transport.request('get_all_account_ids', [] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-  /**
-   * Select account id for internally selected state.
-   * TODO: Likely this is deprecated as all methods take an account id now.
-   */
-  public selectAccount(id: T.U32): Promise<null> {
-    return (this._transport.request('select_account', [id] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get the selected account id of the internal state..
-   * TODO: Likely this is deprecated as all methods take an account id now.
-   */
-  public getSelectedAccountId(): Promise<(T.U32|null)> {
-    return (this._transport.request('get_selected_account_id', [] as RPC.Params)) as Promise<(T.U32|null)>;
-  }
-
-  /**
-   * Get a list of all configured accounts.
-   */
-  public getAllAccounts(): Promise<(T.Account)[]> {
-    return (this._transport.request('get_all_accounts', [] as RPC.Params)) as Promise<(T.Account)[]>;
-  }
-
-
-  public startIoForAllAccounts(): Promise<null> {
-    return (this._transport.request('start_io_for_all_accounts', [] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public stopIoForAllAccounts(): Promise<null> {
-    return (this._transport.request('stop_io_for_all_accounts', [] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public startIo(id: T.U32): Promise<null> {
-    return (this._transport.request('start_io', [id] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public stopIo(id: T.U32): Promise<null> {
-    return (this._transport.request('stop_io', [id] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get top-level info for an account.
-   */
-  public getAccountInfo(accountId: T.U32): Promise<T.Account> {
-    return (this._transport.request('get_account_info', [accountId] as RPC.Params)) as Promise<T.Account>;
-  }
-
-  /**
-   * Get the combined filesize of an account in bytes
-   */
-  public getAccountFileSize(accountId: T.U32): Promise<T.U64> {
-    return (this._transport.request('get_account_file_size', [accountId] as RPC.Params)) as Promise<T.U64>;
-  }
-
-  /**
-   * Returns provider for the given domain.
-   *
-   * This function looks up domain in offline database.
-   *
-   * For compatibility, email address can be passed to this function
-   * instead of the domain.
-   */
-  public getProviderInfo(accountId: T.U32, email: string): Promise<(T.ProviderInfo|null)> {
-    return (this._transport.request('get_provider_info', [accountId, email] as RPC.Params)) as Promise<(T.ProviderInfo|null)>;
-  }
-
-  /**
-   * Checks if the context is already configured.
-   */
-  public isConfigured(accountId: T.U32): Promise<boolean> {
-    return (this._transport.request('is_configured', [accountId] as RPC.Params)) as Promise<boolean>;
-  }
-
-  /**
-   * Get system info for an account.
-   */
-  public getInfo(accountId: T.U32): Promise<Record<string,string>> {
-    return (this._transport.request('get_info', [accountId] as RPC.Params)) as Promise<Record<string,string>>;
-  }
-
-
-  public setConfig(accountId: T.U32, key: string, value: (string|null)): Promise<null> {
-    return (this._transport.request('set_config', [accountId, key, value] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public batchSetConfig(accountId: T.U32, config: Record<string,(string|null)>): Promise<null> {
-    return (this._transport.request('batch_set_config', [accountId, config] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Set configuration values from a QR code. (technically from the URI that is stored in the qrcode)
-   * Before this function is called, `checkQr()` should confirm the type of the
-   * QR code is `account` or `webrtcInstance`.
-   *
-   * Internally, the function will call dc_set_config() with the appropriate keys,
-   */
-  public setConfigFromQr(accountId: T.U32, qrContent: string): Promise<null> {
-    return (this._transport.request('set_config_from_qr', [accountId, qrContent] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public checkQr(accountId: T.U32, qrContent: string): Promise<T.Qr> {
-    return (this._transport.request('check_qr', [accountId, qrContent] as RPC.Params)) as Promise<T.Qr>;
-  }
-
-
-  public getConfig(accountId: T.U32, key: string): Promise<(string|null)> {
-    return (this._transport.request('get_config', [accountId, key] as RPC.Params)) as Promise<(string|null)>;
-  }
-
-
-  public batchGetConfig(accountId: T.U32, keys: (string)[]): Promise<Record<string,(string|null)>> {
-    return (this._transport.request('batch_get_config', [accountId, keys] as RPC.Params)) as Promise<Record<string,(string|null)>>;
-  }
-
-
-  public setStockStrings(strings: Record<T.U32,string>): Promise<null> {
-    return (this._transport.request('set_stock_strings', [strings] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Configures this account with the currently set parameters.
-   * Setup the credential config before calling this.
-   */
-  public configure(accountId: T.U32): Promise<null> {
-    return (this._transport.request('configure', [accountId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Signal an ongoing process to stop.
-   */
-  public stopOngoingProcess(accountId: T.U32): Promise<null> {
-    return (this._transport.request('stop_ongoing_process', [accountId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public exportSelfKeys(accountId: T.U32, path: string, passphrase: (string|null)): Promise<null> {
-    return (this._transport.request('export_self_keys', [accountId, path, passphrase] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public importSelfKeys(accountId: T.U32, path: string, passphrase: (string|null)): Promise<null> {
-    return (this._transport.request('import_self_keys', [accountId, path, passphrase] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Returns the message IDs of all _fresh_ messages of any chat.
-   * Typically used for implementing notification summaries
-   * or badge counters e.g. on the app icon.
-   * The list is already sorted and starts with the most recent fresh message.
-   *
-   * Messages belonging to muted chats or to the contact requests are not returned;
-   * these messages should not be notified
-   * and also badge counters should not include these messages.
-   *
-   * To get the number of fresh messages for a single chat, muted or not,
-   * use `get_fresh_msg_cnt()`.
-   */
-  public getFreshMsgs(accountId: T.U32): Promise<(T.U32)[]> {
-    return (this._transport.request('get_fresh_msgs', [accountId] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-  /**
-   * Get the number of _fresh_ messages in a chat.
-   * Typically used to implement a badge with a number in the chatlist.
-   *
-   * If the specified chat is muted,
-   * the UI should show the badge counter "less obtrusive",
-   * e.g. using "gray" instead of "red" color.
-   */
-  public getFreshMsgCnt(accountId: T.U32, chatId: T.U32): Promise<T.Usize> {
-    return (this._transport.request('get_fresh_msg_cnt', [accountId, chatId] as RPC.Params)) as Promise<T.Usize>;
-  }
-
-  /**
-   * 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
-   * before actually enabling deletion of old messages.
-   */
-  public estimateAutoDeletionCount(accountId: T.U32, fromServer: boolean, seconds: T.I64): Promise<T.Usize> {
-    return (this._transport.request('estimate_auto_deletion_count', [accountId, fromServer, seconds] as RPC.Params)) as Promise<T.Usize>;
-  }
-
-
-  public initiateAutocryptKeyTransfer(accountId: T.U32): Promise<string> {
-    return (this._transport.request('initiate_autocrypt_key_transfer', [accountId] as RPC.Params)) as Promise<string>;
-  }
-
-
-  public continueAutocryptKeyTransfer(accountId: T.U32, messageId: T.U32, setupCode: string): Promise<null> {
-    return (this._transport.request('continue_autocrypt_key_transfer', [accountId, messageId, setupCode] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getChatlistEntries(accountId: T.U32, listFlags: (T.U32|null), queryString: (string|null), queryContactId: (T.U32|null)): Promise<(T.ChatListEntry)[]> {
-    return (this._transport.request('get_chatlist_entries', [accountId, listFlags, queryString, queryContactId] as RPC.Params)) as Promise<(T.ChatListEntry)[]>;
-  }
-
-
-  public getChatlistItemsByEntries(accountId: T.U32, entries: (T.ChatListEntry)[]): Promise<Record<T.U32,T.ChatListItemFetchResult>> {
-    return (this._transport.request('get_chatlist_items_by_entries', [accountId, entries] as RPC.Params)) as Promise<Record<T.U32,T.ChatListItemFetchResult>>;
-  }
-
-
-  public getFullChatById(accountId: T.U32, chatId: T.U32): Promise<T.FullChat> {
-    return (this._transport.request('get_full_chat_by_id', [accountId, chatId] as RPC.Params)) as Promise<T.FullChat>;
-  }
-
-  /**
-   * get basic info about a chat,
-   * use chatlist_get_full_chat_by_id() instead if you need more information
-   */
-  public getBasicChatInfo(accountId: T.U32, chatId: T.U32): Promise<T.BasicChat> {
-    return (this._transport.request('get_basic_chat_info', [accountId, chatId] as RPC.Params)) as Promise<T.BasicChat>;
-  }
-
-
-  public acceptChat(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('accept_chat', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public blockChat(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('block_chat', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Delete a chat.
-   *
-   * Messages are deleted from the device and the chat database entry is deleted.
-   * After that, the event #DC_EVENT_MSGS_CHANGED is posted.
-   *
-   * Things that are _not done_ implicitly:
-   *
-   * - Messages are **not deleted from the server**.
-   * - The chat or the contact is **not blocked**, so new messages from the user/the group may appear as a contact request
-   *   and the user may create the chat again.
-   * - **Groups are not left** - this would
-   *   be unexpected as (1) deleting a normal chat also does not prevent new mails
-   *   from arriving, (2) leaving a group requires sending a message to
-   *   all group members - especially for groups not used for a longer time, this is
-   *   really unexpected when deletion results in contacting all members again,
-   *   (3) only leaving groups is also a valid usecase.
-   *
-   * To leave a chat explicitly, use leave_group()
-   */
-  public deleteChat(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('delete_chat', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get encryption info for a chat.
-   * Get a multi-line encryption info, containing encryption preferences of all members.
-   * Can be used to find out why messages sent to group are not encrypted.
-   *
-   * returns Multi-line text
-   */
-  public getChatEncryptionInfo(accountId: T.U32, chatId: T.U32): Promise<string> {
-    return (this._transport.request('get_chat_encryption_info', [accountId, chatId] as RPC.Params)) as Promise<string>;
-  }
-
-  /**
-   * Get QR code (text and SVG) that will offer an Setup-Contact or Verified-Group invitation.
-   * The QR code is compatible to the OPENPGP4FPR format
-   * so that a basic fingerprint comparison also works e.g. with OpenKeychain.
-   *
-   * The scanning device will pass the scanned content to `checkQr()` then;
-   * if `checkQr()` returns `askVerifyContact` or `askVerifyGroup`
-   * an out-of-band-verification can be joined using `secure_join()`
-   *
-   * chat_id: If set to a group-chat-id,
-   *     the Verified-Group-Invite protocol is offered in the QR code;
-   *     works for protected groups as well as for normal groups.
-   *     If not set, the Setup-Contact protocol is offered in the QR code.
-   *     See https://countermitm.readthedocs.io/en/latest/new.html
-   *     for details about both protocols.
-   *
-   * return format: `[code, svg]`
-   */
-  public getChatSecurejoinQrCodeSvg(accountId: T.U32, chatId: (T.U32|null)): Promise<[string,string]> {
-    return (this._transport.request('get_chat_securejoin_qr_code_svg', [accountId, chatId] as RPC.Params)) as Promise<[string,string]>;
-  }
-
-  /**
-   * Continue a Setup-Contact or Verified-Group-Invite protocol
-   * started on another device with `get_chat_securejoin_qr_code_svg()`.
-   * This function is typically called when `check_qr()` returns
-   * type=AskVerifyContact or type=AskVerifyGroup.
-   *
-   * The function returns immediately and the handshake runs in background,
-   * sending and receiving several messages.
-   * During the handshake, info messages are added to the chat,
-   * showing progress, success or errors.
-   *
-   * Subsequent calls of `secure_join()` will abort previous, unfinished handshakes.
-   *
-   * See https://countermitm.readthedocs.io/en/latest/new.html
-   * for details about both protocols.
-   *
-   * **qr**: The text of the scanned QR code. Typically, the same string as given
-   *     to `check_qr()`.
-   *
-   * **returns**: The chat ID of the joined chat, the UI may redirect to the this chat.
-   *         A returned chat ID does not guarantee that the chat is protected or the belonging contact is verified.
-   *
-   */
-  public secureJoin(accountId: T.U32, qr: string): Promise<T.U32> {
-    return (this._transport.request('secure_join', [accountId, qr] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public leaveGroup(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('leave_group', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Remove a member from a group.
-   *
-   * If the group is already _promoted_ (any message was sent to the group),
-   * all group members are informed by a special status message that is sent automatically by this function.
-   *
-   * Sends out #DC_EVENT_CHAT_MODIFIED and #DC_EVENT_MSGS_CHANGED if a status message was sent.
-   */
-  public removeContactFromChat(accountId: T.U32, chatId: T.U32, contactId: T.U32): Promise<null> {
-    return (this._transport.request('remove_contact_from_chat', [accountId, chatId, contactId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Add a member to a group.
-   *
-   * If the group is already _promoted_ (any message was sent to the group),
-   * all group members are informed by a special status message that is sent automatically by this function.
-   *
-   * If the group has group protection enabled, only verified contacts can be added to the group.
-   *
-   * Sends out #DC_EVENT_CHAT_MODIFIED and #DC_EVENT_MSGS_CHANGED if a status message was sent.
-   */
-  public addContactToChat(accountId: T.U32, chatId: T.U32, contactId: T.U32): Promise<null> {
-    return (this._transport.request('add_contact_to_chat', [accountId, chatId, contactId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get the contact IDs belonging to a chat.
-   *
-   * - for normal chats, the function always returns exactly one contact,
-   *   DC_CONTACT_ID_SELF is returned only for SELF-chats.
-   *
-   * - for group chats all members are returned, DC_CONTACT_ID_SELF is returned
-   *   explicitly as it may happen that oneself gets removed from a still existing
-   *   group
-   *
-   * - for broadcasts, all recipients are returned, DC_CONTACT_ID_SELF is not included
-   *
-   * - for mailing lists, the behavior is not documented currently, we will decide on that later.
-   *   for now, the UI should not show the list for mailing lists.
-   *   (we do not know all members and there is not always a global mailing list address,
-   *   so we could return only SELF or the known members; this is not decided yet)
-   */
-  public getChatContacts(accountId: T.U32, chatId: T.U32): Promise<(T.U32)[]> {
-    return (this._transport.request('get_chat_contacts', [accountId, chatId] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-  /**
-   * Create a new group chat.
-   *
-   * After creation,
-   * the group has one member with the ID DC_CONTACT_ID_SELF
-   * and is in _unpromoted_ state.
-   * This means, you can add or remove members, change the name,
-   * the group image and so on without messages being sent to all group members.
-   *
-   * This changes as soon as the first message is sent to the group members
-   * and the group becomes _promoted_.
-   * After that, all changes are synced with all group members
-   * by sending status message.
-   *
-   * To check, if a chat is still unpromoted, you can look at the `is_unpromoted` property of `BasicChat` or `FullChat`.
-   * This may be useful if you want to show some help for just created groups.
-   *
-   * @param protect If set to 1 the function creates group with protection initially enabled.
-   *     Only verified members are allowed in these groups
-   *     and end-to-end-encryption is always enabled.
-   */
-  public createGroupChat(accountId: T.U32, name: string, protect: boolean): Promise<T.U32> {
-    return (this._transport.request('create_group_chat', [accountId, name, protect] as RPC.Params)) as Promise<T.U32>;
-  }
-
-  /**
-   * 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.
-   *
-   * 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.
-   */
-  public createBroadcastList(accountId: T.U32): Promise<T.U32> {
-    return (this._transport.request('create_broadcast_list', [accountId] as RPC.Params)) as Promise<T.U32>;
-  }
-
-  /**
-   * Set group name.
-   *
-   * If the group is already _promoted_ (any message was sent to the group),
-   * all group members are informed by a special status message that is sent automatically by this function.
-   *
-   * Sends out #DC_EVENT_CHAT_MODIFIED and #DC_EVENT_MSGS_CHANGED if a status message was sent.
-   */
-  public setChatName(accountId: T.U32, chatId: T.U32, newName: string): Promise<null> {
-    return (this._transport.request('set_chat_name', [accountId, chatId, newName] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Set group profile image.
-   *
-   * If the group is already _promoted_ (any message was sent to the group),
-   * all group members are informed by a special status message that is sent automatically by this function.
-   *
-   * Sends out #DC_EVENT_CHAT_MODIFIED and #DC_EVENT_MSGS_CHANGED if a status message was sent.
-   *
-   * To find out the profile image of a chat, use dc_chat_get_profile_image()
-   *
-   * @param image_path Full path of the image to use as the group image. The image will immediately be copied to the
-   *     `blobdir`; the original image will not be needed anymore.
-   *      If you pass null here, the group image is deleted (for promoted groups, all members are informed about
-   *      this change anyway).
-   */
-  public setChatProfileImage(accountId: T.U32, chatId: T.U32, imagePath: (string|null)): Promise<null> {
-    return (this._transport.request('set_chat_profile_image', [accountId, chatId, imagePath] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public setChatVisibility(accountId: T.U32, chatId: T.U32, visibility: T.ChatVisibility): Promise<null> {
-    return (this._transport.request('set_chat_visibility', [accountId, chatId, visibility] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public setChatEphemeralTimer(accountId: T.U32, chatId: T.U32, timer: T.U32): Promise<null> {
-    return (this._transport.request('set_chat_ephemeral_timer', [accountId, chatId, timer] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getChatEphemeralTimer(accountId: T.U32, chatId: T.U32): Promise<T.U32> {
-    return (this._transport.request('get_chat_ephemeral_timer', [accountId, chatId] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public addDeviceMessage(accountId: T.U32, label: string, text: string): Promise<T.U32> {
-    return (this._transport.request('add_device_message', [accountId, label, text] as RPC.Params)) as Promise<T.U32>;
-  }
-
-  /**
-   *  Mark all messages in a chat as _noticed_.
-   *  _Noticed_ messages are no longer _fresh_ and do not count as being unseen
-   *  but are still waiting for being marked as "seen" using markseen_msgs()
-   *  (IMAP/MDNs is not done for noticed messages).
-   *
-   *  Calling this function usually results in the event #DC_EVENT_MSGS_NOTICED.
-   *  See also markseen_msgs().
-   */
-  public marknoticedChat(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('marknoticed_chat', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getFirstUnreadMessageOfChat(accountId: T.U32, chatId: T.U32): Promise<(T.U32|null)> {
-    return (this._transport.request('get_first_unread_message_of_chat', [accountId, chatId] as RPC.Params)) as Promise<(T.U32|null)>;
-  }
-
-  /**
-   * Set mute duration of a chat.
-   *
-   * The UI can then call is_chat_muted() when receiving a new message
-   * to decide whether it should trigger an notification.
-   *
-   * Muted chats should not sound or vibrate
-   * and should not show a visual notification in the system area.
-   * Moreover, muted chats should be excluded from global badge counter
-   * (get_fresh_msgs() skips muted chats therefore)
-   * and the in-app, per-chat badge counter should use a less obtrusive color.
-   *
-   * Sends out #DC_EVENT_CHAT_MODIFIED.
-   */
-  public setChatMuteDuration(accountId: T.U32, chatId: T.U32, duration: T.MuteDuration): Promise<null> {
-    return (this._transport.request('set_chat_mute_duration', [accountId, chatId, duration] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Check whether the chat is currently muted (can be changed by set_chat_mute_duration()).
-   *
-   * This is available as a standalone function outside of fullchat, because it might be only needed for notification
-   */
-  public isChatMuted(accountId: T.U32, chatId: T.U32): Promise<boolean> {
-    return (this._transport.request('is_chat_muted', [accountId, chatId] as RPC.Params)) as Promise<boolean>;
-  }
-
-  /**
-   * Mark messages as presented to the user.
-   * Typically, UIs call this function on scrolling through the message list,
-   * when the messages are presented at least for a little moment.
-   * The concrete action depends on the type of the chat and on the users settings
-   * (dc_msgs_presented() may be a better name therefore, but well. :)
-   *
-   * - For normal chats, the IMAP state is updated, MDN is sent
-   *   (if set_config()-options `mdns_enabled` is set)
-   *   and the internal state is changed to @ref DC_STATE_IN_SEEN to reflect these actions.
-   *
-   * - For contact requests, no IMAP or MDNs is done
-   *   and the internal state is not changed therefore.
-   *   See also marknoticed_chat().
-   *
-   * Moreover, timer is started for incoming ephemeral messages.
-   * This also happens for contact requests chats.
-   *
-   * One #DC_EVENT_MSGS_NOTICED event is emitted per modified chat.
-   */
-  public markseenMsgs(accountId: T.U32, msgIds: (T.U32)[]): Promise<null> {
-    return (this._transport.request('markseen_msgs', [accountId, msgIds] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getMessageIds(accountId: T.U32, chatId: T.U32, flags: T.U32): Promise<(T.U32)[]> {
-    return (this._transport.request('get_message_ids', [accountId, chatId, flags] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-
-  public getMessageListItems(accountId: T.U32, chatId: T.U32, flags: T.U32): Promise<(T.MessageListItem)[]> {
-    return (this._transport.request('get_message_list_items', [accountId, chatId, flags] as RPC.Params)) as Promise<(T.MessageListItem)[]>;
-  }
-
-
-  public getMessage(accountId: T.U32, messageId: T.U32): Promise<T.Message> {
-    return (this._transport.request('get_message', [accountId, messageId] as RPC.Params)) as Promise<T.Message>;
-  }
-
-
-  public getMessageHtml(accountId: T.U32, messageId: T.U32): Promise<(string|null)> {
-    return (this._transport.request('get_message_html', [accountId, messageId] as RPC.Params)) as Promise<(string|null)>;
-  }
-
-
-  public getMessages(accountId: T.U32, messageIds: (T.U32)[]): Promise<Record<T.U32,T.Message>> {
-    return (this._transport.request('get_messages', [accountId, messageIds] as RPC.Params)) as Promise<Record<T.U32,T.Message>>;
-  }
-
-  /**
-   * Fetch info desktop needs for creating a notification for a message
-   */
-  public getMessageNotificationInfo(accountId: T.U32, messageId: T.U32): Promise<T.MessageNotificationInfo> {
-    return (this._transport.request('get_message_notification_info', [accountId, messageId] as RPC.Params)) as Promise<T.MessageNotificationInfo>;
-  }
-
-  /**
-   * Delete messages. The messages are deleted on the current device and
-   * on the IMAP server.
-   */
-  public deleteMessages(accountId: T.U32, messageIds: (T.U32)[]): Promise<null> {
-    return (this._transport.request('delete_messages', [accountId, messageIds] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get an informational text for a single message. The text is multiline and may
-   * contain e.g. the raw text of the message.
-   *
-   * The max. text returned is typically longer (about 100000 characters) than the
-   * max. text returned by dc_msg_get_text() (about 30000 characters).
-   */
-  public getMessageInfo(accountId: T.U32, messageId: T.U32): Promise<string> {
-    return (this._transport.request('get_message_info', [accountId, messageId] as RPC.Params)) as Promise<string>;
-  }
-
-  /**
-   * Asks the core to start downloading a message fully.
-   * This function is typically called when the user hits the "Download" button
-   * that is shown by the UI in case `download_state` is `'Available'` or `'Failure'`
-   *
-   * On success, the @ref DC_MSG "view type of the message" may change
-   * or the message may be replaced completely by one or more messages with other message IDs.
-   * That may happen e.g. in cases where the message was encrypted
-   * and the type could not be determined without fully downloading.
-   * Downloaded content can be accessed as usual after download.
-   *
-   * To reflect these changes a @ref DC_EVENT_MSGS_CHANGED event will be emitted.
-   */
-  public downloadFullMessage(accountId: T.U32, messageId: T.U32): Promise<null> {
-    return (this._transport.request('download_full_message', [accountId, messageId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Search messages containing the given query string.
-   * Searching can be done globally (chat_id=0) 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
-   * 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.
-   */
-  public searchMessages(accountId: T.U32, query: string, chatId: (T.U32|null)): Promise<(T.U32)[]> {
-    return (this._transport.request('search_messages', [accountId, query, chatId] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-
-  public messageIdsToSearchResults(accountId: T.U32, messageIds: (T.U32)[]): Promise<Record<T.U32,T.MessageSearchResult>> {
-    return (this._transport.request('message_ids_to_search_results', [accountId, messageIds] as RPC.Params)) as Promise<Record<T.U32,T.MessageSearchResult>>;
-  }
-
-  /**
-   * Get a single contact options by ID.
-   */
-  public getContact(accountId: T.U32, contactId: T.U32): Promise<T.Contact> {
-    return (this._transport.request('get_contact', [accountId, contactId] as RPC.Params)) as Promise<T.Contact>;
-  }
-
-  /**
-   * Add a single contact as a result of an explicit user action.
-   *
-   * Returns contact id of the created or existing contact
-   */
-  public createContact(accountId: T.U32, email: string, name: (string|null)): Promise<T.U32> {
-    return (this._transport.request('create_contact', [accountId, email, name] as RPC.Params)) as Promise<T.U32>;
-  }
-
-  /**
-   * Returns contact id of the created or existing DM chat with that contact
-   */
-  public createChatByContactId(accountId: T.U32, contactId: T.U32): Promise<T.U32> {
-    return (this._transport.request('create_chat_by_contact_id', [accountId, contactId] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public blockContact(accountId: T.U32, contactId: T.U32): Promise<null> {
-    return (this._transport.request('block_contact', [accountId, contactId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public unblockContact(accountId: T.U32, contactId: T.U32): Promise<null> {
-    return (this._transport.request('unblock_contact', [accountId, contactId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getBlockedContacts(accountId: T.U32): Promise<(T.Contact)[]> {
-    return (this._transport.request('get_blocked_contacts', [accountId] as RPC.Params)) as Promise<(T.Contact)[]>;
-  }
-
-
-  public getContactIds(accountId: T.U32, listFlags: T.U32, query: (string|null)): Promise<(T.U32)[]> {
-    return (this._transport.request('get_contact_ids', [accountId, listFlags, query] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-  /**
-   * Get a list of contacts.
-   * (formerly called getContacts2 in desktop)
-   */
-  public getContacts(accountId: T.U32, listFlags: T.U32, query: (string|null)): Promise<(T.Contact)[]> {
-    return (this._transport.request('get_contacts', [accountId, listFlags, query] as RPC.Params)) as Promise<(T.Contact)[]>;
-  }
-
-
-  public getContactsByIds(accountId: T.U32, ids: (T.U32)[]): Promise<Record<T.U32,T.Contact>> {
-    return (this._transport.request('get_contacts_by_ids', [accountId, ids] as RPC.Params)) as Promise<Record<T.U32,T.Contact>>;
-  }
-
-
-  public deleteContact(accountId: T.U32, contactId: T.U32): Promise<boolean> {
-    return (this._transport.request('delete_contact', [accountId, contactId] as RPC.Params)) as Promise<boolean>;
-  }
-
-
-  public changeContactName(accountId: T.U32, contactId: T.U32, name: string): Promise<null> {
-    return (this._transport.request('change_contact_name', [accountId, contactId, name] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get encryption info for a contact.
-   * Get a multi-line encryption info, containing your fingerprint and the
-   * fingerprint of the contact, used e.g. to compare the fingerprints for a simple out-of-band verification.
-   */
-  public getContactEncryptionInfo(accountId: T.U32, contactId: T.U32): Promise<string> {
-    return (this._transport.request('get_contact_encryption_info', [accountId, contactId] as RPC.Params)) as Promise<string>;
-  }
-
-  /**
-   * Check if an e-mail address belongs to a known and unblocked contact.
-   * To get a list of all known and unblocked contacts, use contacts_get_contacts().
-   *
-   * To validate an e-mail address independently of the contact database
-   * use check_email_validity().
-   */
-  public lookupContactIdByAddr(accountId: T.U32, addr: string): Promise<(T.U32|null)> {
-    return (this._transport.request('lookup_contact_id_by_addr', [accountId, addr] as RPC.Params)) as Promise<(T.U32|null)>;
-  }
-
-  /**
-   * Returns all message IDs of the given types in a chat.
-   * Typically used to show a gallery.
-   *
-   * The list is already sorted and starts with the oldest message.
-   * Clients should not try to re-sort the list as this would be an expensive action
-   * and would result in inconsistencies between clients.
-   *
-   * Setting `chat_id` to `None` (`null` in typescript) means get messages with media
-   * from any chat of the currently used account.
-   */
-  public getChatMedia(accountId: T.U32, chatId: (T.U32|null), messageType: T.Viewtype, orMessageType2: (T.Viewtype|null), orMessageType3: (T.Viewtype|null)): Promise<(T.U32)[]> {
-    return (this._transport.request('get_chat_media', [accountId, chatId, messageType, orMessageType2, orMessageType3] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-  /**
-   * Search next/previous message based on a given message and a list of types.
-   * Typically used to implement the "next" and "previous" buttons
-   * in a gallery or in a media player.
-   *
-   * 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
-   */
-  public getNeighboringChatMedia(accountId: T.U32, msgId: T.U32, messageType: T.Viewtype, orMessageType2: (T.Viewtype|null), orMessageType3: (T.Viewtype|null)): Promise<[(T.U32|null),(T.U32|null)]> {
-    return (this._transport.request('get_neighboring_chat_media', [accountId, msgId, messageType, orMessageType2, orMessageType3] as RPC.Params)) as Promise<[(T.U32|null),(T.U32|null)]>;
-  }
-
-
-  public exportBackup(accountId: T.U32, destination: string, passphrase: (string|null)): Promise<null> {
-    return (this._transport.request('export_backup', [accountId, destination, passphrase] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public importBackup(accountId: T.U32, path: string, passphrase: (string|null)): Promise<null> {
-    return (this._transport.request('import_backup', [accountId, path, passphrase] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Indicate that the network likely has come back.
-   * or just that the network conditions might have changed
-   */
-  public maybeNetwork(): Promise<null> {
-    return (this._transport.request('maybe_network', [] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get the current connectivity, i.e. whether the device is connected to the IMAP server.
-   * One of:
-   * - DC_CONNECTIVITY_NOT_CONNECTED (1000-1999): Show e.g. the string "Not connected" or a red dot
-   * - DC_CONNECTIVITY_CONNECTING (2000-2999): Show e.g. the string "Connecting…" or a yellow dot
-   * - DC_CONNECTIVITY_WORKING (3000-3999): Show e.g. the string "Getting new messages" or a spinning wheel
-   * - DC_CONNECTIVITY_CONNECTED (>=4000): Show e.g. the string "Connected" or a green dot
-   *
-   * We don't use exact values but ranges here so that we can split up
-   * states into multiple states in the future.
-   *
-   * Meant as a rough overview that can be shown
-   * e.g. in the title of the main screen.
-   *
-   * If the connectivity changes, a #DC_EVENT_CONNECTIVITY_CHANGED will be emitted.
-   */
-  public getConnectivity(accountId: T.U32): Promise<T.U32> {
-    return (this._transport.request('get_connectivity', [accountId] as RPC.Params)) as Promise<T.U32>;
-  }
-
-  /**
-   * Get an overview of the current connectivity, and possibly more statistics.
-   * Meant to give the user more insight about the current status than
-   * the basic connectivity info returned by get_connectivity(); show this
-   * e.g., if the user taps on said basic connectivity info.
-   *
-   * If this page changes, a #DC_EVENT_CONNECTIVITY_CHANGED will be emitted.
-   *
-   * This comes as an HTML from the core so that we can easily improve it
-   * and the improvement instantly reaches all UIs.
-   */
-  public getConnectivityHtml(accountId: T.U32): Promise<string> {
-    return (this._transport.request('get_connectivity_html', [accountId] as RPC.Params)) as Promise<string>;
-  }
-
-
-  public getLocations(accountId: T.U32, chatId: (T.U32|null), contactId: (T.U32|null), timestampBegin: T.I64, timestampEnd: T.I64): Promise<(T.Location)[]> {
-    return (this._transport.request('get_locations', [accountId, chatId, contactId, timestampBegin, timestampEnd] as RPC.Params)) as Promise<(T.Location)[]>;
-  }
-
-
-  public sendWebxdcStatusUpdate(accountId: T.U32, instanceMsgId: T.U32, updateStr: string, description: string): Promise<null> {
-    return (this._transport.request('send_webxdc_status_update', [accountId, instanceMsgId, updateStr, description] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getWebxdcStatusUpdates(accountId: T.U32, instanceMsgId: T.U32, lastKnownSerial: T.U32): Promise<string> {
-    return (this._transport.request('get_webxdc_status_updates', [accountId, instanceMsgId, lastKnownSerial] as RPC.Params)) as Promise<string>;
-  }
-
-  /**
-   * Get info from a webxdc message
-   */
-  public getWebxdcInfo(accountId: T.U32, instanceMsgId: T.U32): Promise<T.WebxdcMessageInfo> {
-    return (this._transport.request('get_webxdc_info', [accountId, instanceMsgId] as RPC.Params)) as Promise<T.WebxdcMessageInfo>;
-  }
-
-  /**
-   * Forward messages to another chat.
-   *
-   * All types of messages can be forwarded,
-   * however, they will be flagged as such (dc_msg_is_forwarded() is set).
-   *
-   * Original sender, info-state and webxdc updates are not forwarded on purpose.
-   */
-  public forwardMessages(accountId: T.U32, messageIds: (T.U32)[], chatId: T.U32): Promise<null> {
-    return (this._transport.request('forward_messages', [accountId, messageIds, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public sendSticker(accountId: T.U32, chatId: T.U32, stickerPath: string): Promise<T.U32> {
-    return (this._transport.request('send_sticker', [accountId, chatId, stickerPath] as RPC.Params)) as Promise<T.U32>;
-  }
-
-  /**
-   * Send a reaction to message.
-   *
-   * Reaction is a string of emojis separated by spaces. Reaction to a
-   * single message can be sent multiple times. The last reaction
-   * received overrides all previously received reactions. It is
-   * possible to remove all reactions by sending an empty string.
-   */
-  public sendReaction(accountId: T.U32, messageId: T.U32, reaction: (string)[]): Promise<T.U32> {
-    return (this._transport.request('send_reaction', [accountId, messageId, reaction] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public removeDraft(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('remove_draft', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   *  Get draft for a chat, if any.
-   */
-  public getDraft(accountId: T.U32, chatId: T.U32): Promise<(T.Message|null)> {
-    return (this._transport.request('get_draft', [accountId, chatId] as RPC.Params)) as Promise<(T.Message|null)>;
-  }
-
-
-  public sendVideochatInvitation(accountId: T.U32, chatId: T.U32): Promise<T.U32> {
-    return (this._transport.request('send_videochat_invitation', [accountId, chatId] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public miscGetStickerFolder(accountId: T.U32): Promise<string> {
-    return (this._transport.request('misc_get_sticker_folder', [accountId] as RPC.Params)) as Promise<string>;
-  }
-
-  /**
-   * save a sticker to a collection/folder in the account's sticker folder
-   */
-  public miscSaveSticker(accountId: T.U32, msgId: T.U32, collection: string): Promise<null> {
-    return (this._transport.request('misc_save_sticker', [accountId, msgId, collection] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * for desktop, get stickers from stickers folder,
-   * grouped by the collection/folder they are in.
-   */
-  public miscGetStickers(accountId: T.U32): Promise<Record<string,(string)[]>> {
-    return (this._transport.request('misc_get_stickers', [accountId] as RPC.Params)) as Promise<Record<string,(string)[]>>;
-  }
-
-  /**
-   * Returns the messageid of the sent message
-   */
-  public miscSendTextMessage(accountId: T.U32, chatId: T.U32, text: string): Promise<T.U32> {
-    return (this._transport.request('misc_send_text_message', [accountId, chatId, text] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public miscSendMsg(accountId: T.U32, chatId: T.U32, text: (string|null), file: (string|null), location: ([T.F64,T.F64]|null), quotedMessageId: (T.U32|null)): Promise<[T.U32,T.Message]> {
-    return (this._transport.request('misc_send_msg', [accountId, chatId, text, file, location, quotedMessageId] as RPC.Params)) as Promise<[T.U32,T.Message]>;
-  }
-
-
-  public miscSetDraft(accountId: T.U32, chatId: T.U32, text: (string|null), file: (string|null), quotedMessageId: (T.U32|null)): Promise<null> {
-    return (this._transport.request('misc_set_draft', [accountId, chatId, text, file, quotedMessageId] as RPC.Params)) as Promise<null>;
-  }
-
-
-}

deltachat-jsonrpc/typescript/generated/constants.ts

@@ -1,199 +0,0 @@
-// Generated!
-
-export enum C {
-  DC_CERTCK_ACCEPT_INVALID_CERTIFICATES = 3,
-  DC_CERTCK_AUTO = 0,
-  DC_CERTCK_STRICT = 1,
-  DC_CHAT_ID_ALLDONE_HINT = 7,
-  DC_CHAT_ID_ARCHIVED_LINK = 6,
-  DC_CHAT_ID_LAST_SPECIAL = 9,
-  DC_CHAT_ID_TRASH = 3,
-  DC_CHAT_TYPE_BROADCAST = 160,
-  DC_CHAT_TYPE_GROUP = 120,
-  DC_CHAT_TYPE_MAILINGLIST = 140,
-  DC_CHAT_TYPE_SINGLE = 100,
-  DC_CHAT_TYPE_UNDEFINED = 0,
-  DC_CONNECTIVITY_CONNECTED = 4000,
-  DC_CONNECTIVITY_CONNECTING = 2000,
-  DC_CONNECTIVITY_NOT_CONNECTED = 1000,
-  DC_CONNECTIVITY_WORKING = 3000,
-  DC_CONTACT_ID_DEVICE = 5,
-  DC_CONTACT_ID_INFO = 2,
-  DC_CONTACT_ID_LAST_SPECIAL = 9,
-  DC_CONTACT_ID_SELF = 1,
-  DC_GCL_ADD_ALLDONE_HINT = 4,
-  DC_GCL_ADD_SELF = 2,
-  DC_GCL_ARCHIVED_ONLY = 1,
-  DC_GCL_FOR_FORWARDING = 8,
-  DC_GCL_NO_SPECIALS = 2,
-  DC_GCL_VERIFIED_ONLY = 1,
-  DC_GCM_ADDDAYMARKER = 1,
-  DC_GCM_INFO_ONLY = 2,
-  DC_KEY_GEN_DEFAULT = 0,
-  DC_KEY_GEN_ED25519 = 2,
-  DC_KEY_GEN_RSA2048 = 1,
-  DC_LP_AUTH_NORMAL = 4,
-  DC_LP_AUTH_OAUTH2 = 2,
-  DC_MEDIA_QUALITY_BALANCED = 0,
-  DC_MEDIA_QUALITY_WORSE = 1,
-  DC_MSG_ID_DAYMARKER = 9,
-  DC_MSG_ID_LAST_SPECIAL = 9,
-  DC_MSG_ID_MARKER1 = 1,
-  DC_PROVIDER_STATUS_BROKEN = 3,
-  DC_PROVIDER_STATUS_OK = 1,
-  DC_PROVIDER_STATUS_PREPARATION = 2,
-  DC_SHOW_EMAILS_ACCEPTED_CONTACTS = 1,
-  DC_SHOW_EMAILS_ALL = 2,
-  DC_SHOW_EMAILS_OFF = 0,
-  DC_SOCKET_AUTO = 0,
-  DC_SOCKET_PLAIN = 3,
-  DC_SOCKET_SSL = 1,
-  DC_SOCKET_STARTTLS = 2,
-  DC_STATE_IN_FRESH = 10,
-  DC_STATE_IN_NOTICED = 13,
-  DC_STATE_IN_SEEN = 16,
-  DC_STATE_OUT_DELIVERED = 26,
-  DC_STATE_OUT_DRAFT = 19,
-  DC_STATE_OUT_FAILED = 24,
-  DC_STATE_OUT_MDN_RCVD = 28,
-  DC_STATE_OUT_PENDING = 20,
-  DC_STATE_OUT_PREPARING = 18,
-  DC_STATE_UNDEFINED = 0,
-  DC_STR_AC_SETUP_MSG_BODY = 43,
-  DC_STR_AC_SETUP_MSG_SUBJECT = 42,
-  DC_STR_ADD_MEMBER_BY_OTHER = 129,
-  DC_STR_ADD_MEMBER_BY_YOU = 128,
-  DC_STR_AEAP_ADDR_CHANGED = 122,
-  DC_STR_AEAP_EXPLANATION_AND_LINK = 123,
-  DC_STR_ARCHIVEDCHATS = 40,
-  DC_STR_AUDIO = 11,
-  DC_STR_BAD_TIME_MSG_BODY = 85,
-  DC_STR_BROADCAST_LIST = 115,
-  DC_STR_CANNOT_LOGIN = 60,
-  DC_STR_CANTDECRYPT_MSG_BODY = 29,
-  DC_STR_CONFIGURATION_FAILED = 84,
-  DC_STR_CONNECTED = 107,
-  DC_STR_CONNTECTING = 108,
-  DC_STR_CONTACT_NOT_VERIFIED = 36,
-  DC_STR_CONTACT_SETUP_CHANGED = 37,
-  DC_STR_CONTACT_VERIFIED = 35,
-  DC_STR_DEVICE_MESSAGES = 68,
-  DC_STR_DEVICE_MESSAGES_HINT = 70,
-  DC_STR_DOWNLOAD_AVAILABILITY = 100,
-  DC_STR_DRAFT = 3,
-  DC_STR_E2E_AVAILABLE = 25,
-  DC_STR_E2E_PREFERRED = 34,
-  DC_STR_ENCRYPTEDMSG = 24,
-  DC_STR_ENCR_NONE = 28,
-  DC_STR_ENCR_TRANSP = 27,
-  DC_STR_EPHEMERAL_DAY = 79,
-  DC_STR_EPHEMERAL_DAYS = 95,
-  DC_STR_EPHEMERAL_DISABLED = 75,
-  DC_STR_EPHEMERAL_FOUR_WEEKS = 81,
-  DC_STR_EPHEMERAL_HOUR = 78,
-  DC_STR_EPHEMERAL_HOURS = 94,
-  DC_STR_EPHEMERAL_MINUTE = 77,
-  DC_STR_EPHEMERAL_MINUTES = 93,
-  DC_STR_EPHEMERAL_SECONDS = 76,
-  DC_STR_EPHEMERAL_TIMER_1_DAY_BY_OTHER = 147,
-  DC_STR_EPHEMERAL_TIMER_1_DAY_BY_YOU = 146,
-  DC_STR_EPHEMERAL_TIMER_1_HOUR_BY_OTHER = 145,
-  DC_STR_EPHEMERAL_TIMER_1_HOUR_BY_YOU = 144,
-  DC_STR_EPHEMERAL_TIMER_1_MINUTE_BY_OTHER = 143,
-  DC_STR_EPHEMERAL_TIMER_1_MINUTE_BY_YOU = 142,
-  DC_STR_EPHEMERAL_TIMER_1_WEEK_BY_OTHER = 149,
-  DC_STR_EPHEMERAL_TIMER_1_WEEK_BY_YOU = 148,
-  DC_STR_EPHEMERAL_TIMER_DAYS_BY_OTHER = 155,
-  DC_STR_EPHEMERAL_TIMER_DAYS_BY_YOU = 154,
-  DC_STR_EPHEMERAL_TIMER_DISABLED_BY_OTHER = 139,
-  DC_STR_EPHEMERAL_TIMER_DISABLED_BY_YOU = 138,
-  DC_STR_EPHEMERAL_TIMER_HOURS_BY_OTHER = 153,
-  DC_STR_EPHEMERAL_TIMER_HOURS_BY_YOU = 152,
-  DC_STR_EPHEMERAL_TIMER_MINUTES_BY_OTHER = 151,
-  DC_STR_EPHEMERAL_TIMER_MINUTES_BY_YOU = 150,
-  DC_STR_EPHEMERAL_TIMER_SECONDS_BY_OTHER = 141,
-  DC_STR_EPHEMERAL_TIMER_SECONDS_BY_YOU = 140,
-  DC_STR_EPHEMERAL_TIMER_WEEKS_BY_OTHER = 157,
-  DC_STR_EPHEMERAL_TIMER_WEEKS_BY_YOU = 156,
-  DC_STR_EPHEMERAL_WEEK = 80,
-  DC_STR_EPHEMERAL_WEEKS = 96,
-  DC_STR_ERROR = 112,
-  DC_STR_ERROR_NO_NETWORK = 87,
-  DC_STR_FAILED_SENDING_TO = 74,
-  DC_STR_FILE = 12,
-  DC_STR_FINGERPRINTS = 30,
-  DC_STR_FORWARDED = 97,
-  DC_STR_GIF = 23,
-  DC_STR_GROUP_IMAGE_CHANGED_BY_OTHER = 127,
-  DC_STR_GROUP_IMAGE_CHANGED_BY_YOU = 126,
-  DC_STR_GROUP_IMAGE_DELETED_BY_OTHER = 135,
-  DC_STR_GROUP_IMAGE_DELETED_BY_YOU = 134,
-  DC_STR_GROUP_LEFT_BY_OTHER = 133,
-  DC_STR_GROUP_LEFT_BY_YOU = 132,
-  DC_STR_GROUP_NAME_CHANGED_BY_OTHER = 125,
-  DC_STR_GROUP_NAME_CHANGED_BY_YOU = 124,
-  DC_STR_IMAGE = 9,
-  DC_STR_INCOMING_MESSAGES = 103,
-  DC_STR_LAST_MSG_SENT_SUCCESSFULLY = 111,
-  DC_STR_LOCATION = 66,
-  DC_STR_LOCATION_ENABLED_BY_OTHER = 137,
-  DC_STR_LOCATION_ENABLED_BY_YOU = 136,
-  DC_STR_MESSAGES = 114,
-  DC_STR_MSGACTIONBYME = 63,
-  DC_STR_MSGACTIONBYUSER = 62,
-  DC_STR_MSGADDMEMBER = 17,
-  DC_STR_MSGDELMEMBER = 18,
-  DC_STR_MSGGROUPLEFT = 19,
-  DC_STR_MSGGRPIMGCHANGED = 16,
-  DC_STR_MSGGRPIMGDELETED = 33,
-  DC_STR_MSGGRPNAME = 15,
-  DC_STR_MSGLOCATIONDISABLED = 65,
-  DC_STR_MSGLOCATIONENABLED = 64,
-  DC_STR_NOMESSAGES = 1,
-  DC_STR_NOT_CONNECTED = 121,
-  DC_STR_NOT_SUPPORTED_BY_PROVIDER = 113,
-  DC_STR_ONE_MOMENT = 106,
-  DC_STR_OUTGOING_MESSAGES = 104,
-  DC_STR_PARTIAL_DOWNLOAD_MSG_BODY = 99,
-  DC_STR_PART_OF_TOTAL_USED = 116,
-  DC_STR_PROTECTION_DISABLED = 89,
-  DC_STR_PROTECTION_DISABLED_BY_OTHER = 161,
-  DC_STR_PROTECTION_DISABLED_BY_YOU = 160,
-  DC_STR_PROTECTION_ENABLED = 88,
-  DC_STR_PROTECTION_ENABLED_BY_OTHER = 159,
-  DC_STR_PROTECTION_ENABLED_BY_YOU = 158,
-  DC_STR_QUOTA_EXCEEDING_MSG_BODY = 98,
-  DC_STR_READRCPT = 31,
-  DC_STR_READRCPT_MAILBODY = 32,
-  DC_STR_REMOVE_MEMBER_BY_OTHER = 131,
-  DC_STR_REMOVE_MEMBER_BY_YOU = 130,
-  DC_STR_REPLY_NOUN = 90,
-  DC_STR_SAVED_MESSAGES = 69,
-  DC_STR_SECURE_JOIN_GROUP_QR_DESC = 120,
-  DC_STR_SECURE_JOIN_REPLIES = 118,
-  DC_STR_SECURE_JOIN_STARTED = 117,
-  DC_STR_SELF = 2,
-  DC_STR_SELF_DELETED_MSG_BODY = 91,
-  DC_STR_SENDING = 110,
-  DC_STR_SERVER_TURNED_OFF = 92,
-  DC_STR_SETUP_CONTACT_QR_DESC = 119,
-  DC_STR_STICKER = 67,
-  DC_STR_STORAGE_ON_DOMAIN = 105,
-  DC_STR_SUBJECT_FOR_NEW_CONTACT = 73,
-  DC_STR_SYNC_MSG_BODY = 102,
-  DC_STR_SYNC_MSG_SUBJECT = 101,
-  DC_STR_UNKNOWN_SENDER_FOR_CHAT = 72,
-  DC_STR_UPDATE_REMINDER_MSG_BODY = 86,
-  DC_STR_UPDATING = 109,
-  DC_STR_VIDEO = 10,
-  DC_STR_VIDEOCHAT_INVITATION = 82,
-  DC_STR_VIDEOCHAT_INVITE_MSG_BODY = 83,
-  DC_STR_VOICEMESSAGE = 7,
-  DC_STR_WELCOME_MESSAGE = 71,
-  DC_TEXT1_DRAFT = 1,
-  DC_TEXT1_SELF = 3,
-  DC_TEXT1_USERNAME = 2,
-  DC_VIDEOCHATTYPE_BASICWEBRTC = 1,
-  DC_VIDEOCHATTYPE_JITSI = 2,
-  DC_VIDEOCHATTYPE_UNKNOWN = 0,
-}

deltachat-jsonrpc/typescript/generated/events.ts

@@ -1,214 +0,0 @@
-// AUTO-GENERATED by typescript-type-def
-
-export type U32=number;
-export type Usize=number;
-export type Event=(({
-/**
- * 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
- * that.
- */
-"type":"Info";}&{"msg":string;})|({
-/**
- * Emitted when SMTP connection is established and login was successful.
- */
-"type":"SmtpConnected";}&{"msg":string;})|({
-/**
- * Emitted when IMAP connection is established and login was successful.
- */
-"type":"ImapConnected";}&{"msg":string;})|({
-/**
- * Emitted when a message was successfully sent to the SMTP server.
- */
-"type":"SmtpMessageSent";}&{"msg":string;})|({
-/**
- * Emitted when an IMAP message has been marked as deleted
- */
-"type":"ImapMessageDeleted";}&{"msg":string;})|({
-/**
- * Emitted when an IMAP message has been moved
- */
-"type":"ImapMessageMoved";}&{"msg":string;})|({
-/**
- * Emitted when an new file in the $BLOBDIR was created
- */
-"type":"NewBlobFile";}&{"file":string;})|({
-/**
- * Emitted when an file in the $BLOBDIR was deleted
- */
-"type":"DeletedBlobFile";}&{"file":string;})|({
-/**
- * The library-user should write a warning string to the log.
- * 
- * This event should *not* be reported to the end-user using a popup or something like
- * that.
- */
-"type":"Warning";}&{"msg":string;})|({
-/**
- * The library-user should report an error to the end-user.
- * 
- * As most things are asynchronous, things may go wrong at any time and the user
- * should not be disturbed by a dialog or so.  Instead, use a bubble or so.
- * 
- * However, for ongoing processes (eg. configure())
- * or for functions that are expected to fail (eg. autocryptContinueKeyTransfer())
- * it might be better to delay showing these events until the function has really
- * failed (returned false). It should be sufficient to report only the *last* error
- * in a messasge box then.
- */
-"type":"Error";}&{"msg":string;})|({
-/**
- * An action cannot be performed because the user is not in the group.
- * Reported eg. after a call to
- * setChatName(), setChatProfileImage(),
- * addContactToChat(), removeContactFromChat(),
- * and messages sending functions.
- */
-"type":"ErrorSelfNotInGroup";}&{"msg":string;})|({
-/**
- * Messages or chats changed.  One or more messages or chats changed for various
- * reasons in the database:
- * - Messages sent, received or removed
- * - Chats created, deleted or archived
- * - A draft has been set
- * 
- * `chatId` is set if only a single chat is affected by the changes, otherwise 0.
- * `msgId` is set if only a single message is affected by the changes, otherwise 0.
- */
-"type":"MsgsChanged";}&{"chatId":U32;"msgId":U32;})|({
-/**
- * Reactions for the message changed.
- */
-"type":"ReactionsChanged";}&{"chatId":U32;"msgId":U32;"contactId":U32;})|({
-/**
- * There is a fresh message. Typically, the user will show an notification
- * when receiving this message.
- * 
- * There is no extra #DC_EVENT_MSGS_CHANGED event send together with this event.
- */
-"type":"IncomingMsg";}&{"chatId":U32;"msgId":U32;})|({
-/**
- * Downloading a bunch of messages just finished. This is an experimental
- * event to allow the UI to only show one notification per message bunch,
- * instead of cluttering the user with many notifications.
- * 
- * msg_ids contains the message ids.
- */
-"type":"IncomingMsgBunch";}&{"msgIds":(U32)[];})|({
-/**
- * Messages were seen or noticed.
- * chat id is always set.
- */
-"type":"MsgsNoticed";}&{"chatId":U32;})|({
-/**
- * A single message is sent successfully. State changed from  DC_STATE_OUT_PENDING to
- * DC_STATE_OUT_DELIVERED, see `Message.state`.
- */
-"type":"MsgDelivered";}&{"chatId":U32;"msgId":U32;})|({
-/**
- * A single message could not be sent. State changed from DC_STATE_OUT_PENDING or DC_STATE_OUT_DELIVERED to
- * DC_STATE_OUT_FAILED, see `Message.state`.
- */
-"type":"MsgFailed";}&{"chatId":U32;"msgId":U32;})|({
-/**
- * A single message is read by the receiver. State changed from DC_STATE_OUT_DELIVERED to
- * DC_STATE_OUT_MDN_RCVD, see `Message.state`.
- */
-"type":"MsgRead";}&{"chatId":U32;"msgId":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()
- * and removeContactFromChat().
- * 
- * This event does not include ephemeral timer modification, which
- * is a separate event.
- */
-"type":"ChatModified";}&{"chatId":U32;})|({
-/**
- * Chat ephemeral timer changed.
- */
-"type":"ChatEphemeralTimerModified";}&{"chatId":U32;"timer":U32;})|({
-/**
- * Contact(s) created, renamed, blocked or deleted.
- * 
- * @param data1 (int) If set, this is the contact_id of an added contact that should be selected.
- */
-"type":"ContactsChanged";}&{"contactId":(U32|null);})|({
-/**
- * Location of one or more contact has changed.
- * 
- * @param data1 (u32) contact_id of the contact for which the location has changed.
- *     If the locations of several contacts have been changed,
- *     this parameter is set to `None`.
- */
-"type":"LocationChanged";}&{"contactId":(U32|null);})|({
-/**
- * Inform about the configuration progress started by configure().
- */
-"type":"ConfigureProgress";}&{
-/**
- * Progress.
- * 
- * 0=error, 1-999=progress in permille, 1000=success and done
- */
-"progress":Usize;
-/**
- * Progress comment or error, something to display to the user.
- */
-"comment":(string|null);})|({
-/**
- * Inform about the import/export progress started by imex().
- * 
- * @param data1 (usize) 0=error, 1-999=progress in permille, 1000=success and done
- * @param data2 0
- */
-"type":"ImexProgress";}&{"progress":Usize;})|({
-/**
- * A file has been exported. A file has been written by imex().
- * This event may be sent multiple times by a single call to imex().
- * 
- * A typical purpose for a handler of this event may be to make the file public to some system
- * services.
- * 
- * @param data2 0
- */
-"type":"ImexFileWritten";}&{"path":string;})|({
-/**
- * Progress information of a secure-join handshake from the view of the inviter
- * (Alice, the person who shows the QR code).
- * 
- * These events are typically sent after a joiner has scanned the QR code
- * generated by getChatSecurejoinQrCodeSvg().
- * 
- * @param data1 (int) ID of the contact that wants to join.
- * @param data2 (int) Progress as:
- *     300=vg-/vc-request received, typically shown as "bob@addr joins".
- *     600=vg-/vc-request-with-auth received, vg-member-added/vc-contact-confirm sent, typically shown as "bob@addr verified".
- *     800=vg-member-added-received received, shown as "bob@addr securely joined GROUP", only sent for the verified-group-protocol.
- *     1000=Protocol finished for this contact.
- */
-"type":"SecurejoinInviterProgress";}&{"contactId":U32;"progress":Usize;})|({
-/**
- * Progress information of a secure-join handshake from the view of the joiner
- * (Bob, the person who scans the QR code).
- * The events are typically sent while secureJoin(), which
- * may take some time, is executed.
- * @param data1 (int) ID of the inviting contact.
- * @param data2 (int) Progress as:
- *     400=vg-/vc-request-with-auth sent, typically shown as "alice@addr verified, introducing myself."
- *     (Bob has verified alice and waits until Alice does the same for him)
- */
-"type":"SecurejoinJoinerProgress";}&{"contactId":U32;"progress":Usize;})|{
-/**
- * The connectivity to the server changed.
- * This means that you should refresh the connectivity view
- * and possibly the connectivtiy HTML; see getConnectivity() and
- * getConnectivityHtml() for details.
- */
-"type":"ConnectivityChanged";}|{"type":"SelfavatarChanged";}|({"type":"WebxdcStatusUpdate";}&{"msgId":U32;"statusUpdateSerial":U32;})|({
-/**
- * Inform that a message containing a webxdc instance has been deleted
- */
-"type":"WebxdcInstanceDeleted";}&{"msgId":U32;}));

deltachat-jsonrpc/typescript/generated/jsonrpc.ts

@@ -1,10 +0,0 @@
-// AUTO-GENERATED by typescript-type-def
-
-export type JSONValue=(null|boolean|number|string|(JSONValue)[]|{[key:string]:JSONValue;});
-export type Params=((JSONValue)[]|Record<string,JSONValue>);
-export type U32=number;
-export type Request={"jsonrpc":"2.0";"method":string;"params"?:Params;"id"?:U32;};
-export type I32=number;
-export type Error={"code":I32;"message":string;"data"?:JSONValue;};
-export type Response={"jsonrpc":"2.0";"id":(U32|null);"result"?:JSONValue;"error"?:Error;};
-export type Message=(Request|Response);

deltachat-jsonrpc/typescript/generated/types.ts

@@ -1,198 +0,0 @@
-// AUTO-GENERATED by typescript-type-def
-
-export type U32=number;
-export type Account=(({"type":"Configured";}&{"id":U32;"displayName":(string|null);"addr":(string|null);"profileImage":(string|null);"color":string;})|({"type":"Unconfigured";}&{"id":U32;}));
-export type U64=number;
-export type ProviderInfo={"beforeLoginHint":string;"overviewPage":string;"status":U32;};
-export type Qr=(({"type":"askVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"askVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"fprOk";}&{"contact_id":U32;})|({"type":"fprMismatch";}&{"contact_id":(U32|null);})|({"type":"fprWithoutAddr";}&{"fingerprint":string;})|({"type":"account";}&{"domain":string;})|({"type":"webrtcInstance";}&{"domain":string;"instance_pattern":string;})|({"type":"addr";}&{"contact_id":U32;"draft":(string|null);})|({"type":"url";}&{"url":string;})|({"type":"text";}&{"text":string;})|({"type":"withdrawVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"withdrawVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"reviveVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"reviveVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"login";}&{"address":string;}));
-export type Usize=number;
-export type I64=number;
-export type ChatListEntry=[U32,U32];
-export type ChatListItemFetchResult=(({"type":"ChatListItem";}&{"id":U32;"name":string;"avatarPath":(string|null);"color":string;"lastUpdated":(I64|null);"summaryText1":string;"summaryText2":string;"summaryStatus":U32;"isProtected":boolean;"isGroup":boolean;"freshMessageCounter":Usize;"isSelfTalk":boolean;"isDeviceTalk":boolean;"isSendingLocation":boolean;"isSelfInGroup":boolean;"isArchived":boolean;"isPinned":boolean;"isMuted":boolean;"isContactRequest":boolean;
-/**
- * true when chat is a broadcastlist
- */
-"isBroadcast":boolean;
-/**
- * contact id if this is a dm chat (for view profile entry in context menu)
- */
-"dmChatContact":(U32|null);"wasSeenRecently":boolean;})|{"type":"ArchiveLink";}|({"type":"Error";}&{"id":U32;"error":string;}));
-export type Contact={"address":string;"color":string;"authName":string;"status":string;"displayName":string;"id":U32;"name":string;"profileImage":(string|null);"nameAndAddr":string;"isBlocked":boolean;"isVerified":boolean;
-/**
- * the contact's last seen timestamp
- */
-"lastSeen":I64;"wasSeenRecently":boolean;};
-export type FullChat={"id":U32;"name":string;"isProtected":boolean;"profileImage":(string|null);"archived":boolean;"chatType":U32;"isUnpromoted":boolean;"isSelfTalk":boolean;"contacts":(Contact)[];"contactIds":(U32)[];"color":string;"freshMessageCounter":Usize;"isContactRequest":boolean;"isDeviceChat":boolean;"selfInGroup":boolean;"isMuted":boolean;"ephemeralTimer":U32;"canSend":boolean;"wasSeenRecently":boolean;"mailingListAddress":(string|null);};
-
-/**
- * cheaper version of fullchat, omits:
- * - contacts
- * - contact_ids
- * - fresh_message_counter
- * - ephemeral_timer
- * - self_in_group
- * - was_seen_recently
- * - can_send
- * 
- * used when you only need the basic metadata of a chat like type, name, profile picture
- */
-export type BasicChat=
-/**
- * cheaper version of fullchat, omits:
- * - contacts
- * - contact_ids
- * - fresh_message_counter
- * - ephemeral_timer
- * - self_in_group
- * - was_seen_recently
- * - can_send
- * 
- * used when you only need the basic metadata of a chat like type, name, profile picture
- */
-{"id":U32;"name":string;"isProtected":boolean;"profileImage":(string|null);"archived":boolean;"chatType":U32;"isUnpromoted":boolean;"isSelfTalk":boolean;"color":string;"isContactRequest":boolean;"isDeviceChat":boolean;"isMuted":boolean;};
-export type ChatVisibility=("Normal"|"Archived"|"Pinned");
-export type MuteDuration=("NotMuted"|"Forever"|{"Until":I64;});
-export type MessageListItem=(({"kind":"message";}&{"msg_id":U32;})|({
-/**
- * Day marker, separating messages that correspond to different
- * days according to local time.
- */
-"kind":"dayMarker";}&{
-/**
- * Marker timestamp, for day markers, in unix milliseconds
- */
-"timestamp":I64;}));
-export type Viewtype=("Unknown"|
-/**
- * Text message.
- */
-"Text"|
-/**
- * Image message.
- * If the image is an animated GIF, the type `Viewtype.Gif` should be used.
- */
-"Image"|
-/**
- * Animated GIF message.
- */
-"Gif"|
-/**
- * Message containing a sticker, similar to image.
- * If possible, the ui should display the image without borders in a transparent way.
- * A click on a sticker will offer to install the sticker set in some future.
- */
-"Sticker"|
-/**
- * Message containing an Audio file.
- */
-"Audio"|
-/**
- * A voice message that was directly recorded by the user.
- * For all other audio messages, the type `Viewtype.Audio` should be used.
- */
-"Voice"|
-/**
- * Video messages.
- */
-"Video"|
-/**
- * Message containing any file, eg. a PDF.
- */
-"File"|
-/**
- * Message is an invitation to a videochat.
- */
-"VideochatInvitation"|
-/**
- * Message is an webxdc instance.
- */
-"Webxdc");
-export type MessageQuote=(({"kind":"JustText";}&{"text":string;})|({"kind":"WithMessage";}&{"text":string;"messageId":U32;"authorDisplayName":string;"authorDisplayColor":string;"overrideSenderName":(string|null);"image":(string|null);"isForwarded":boolean;"viewType":Viewtype;}));
-export type SystemMessageType=("Unknown"|"GroupNameChanged"|"GroupImageChanged"|"MemberAddedToGroup"|"MemberRemovedFromGroup"|"AutocryptSetupMessage"|"SecurejoinMessage"|"LocationStreamingEnabled"|"LocationOnly"|
-/**
- * Chat ephemeral message timer is changed.
- */
-"EphemeralTimerChanged"|"ChatProtectionEnabled"|"ChatProtectionDisabled"|
-/**
- * Self-sent-message that contains only json used for multi-device-sync;
- * if possible, we attach that to other messages as for locations.
- */
-"MultiDeviceSync"|"WebxdcStatusUpdate"|
-/**
- * Webxdc info added with `info` set in `send_webxdc_status_update()`.
- */
-"WebxdcInfoMessage");
-export type I32=number;
-export type WebxdcMessageInfo={
-/**
- * The name of the app.
- * 
- * Defaults to the filename if not set in the manifest.
- */
-"name":string;
-/**
- * App icon file name.
- * Defaults to an standard icon if nothing is set in the manifest.
- * 
- * To get the file, use dc_msg_get_webxdc_blob(). (not yet in jsonrpc, use rust api or cffi for it)
- * 
- * App icons should should be square,
- * the implementations will add round corners etc. as needed.
- */
-"icon":string;
-/**
- * if the Webxdc represents a document, then this is the name of the document
- */
-"document":(string|null);
-/**
- * short string describing the state of the app,
- * sth. as "2 votes", "Highscore: 123",
- * can be changed by the apps
- */
-"summary":(string|null);
-/**
- * URL where the source code of the Webxdc and other information can be found;
- * defaults to an empty string.
- * Implementations may offer an menu or a button to open this URL.
- */
-"sourceCodeUrl":(string|null);
-/**
- * True if full internet access should be granted to the app.
- */
-"internetAccess":boolean;};
-export type DownloadState=("Done"|"Available"|"Failure"|"InProgress");
-
-/**
- * Structure representing all reactions to a particular message.
- */
-export type Reactions=
-/**
- * Structure representing all reactions to a particular message.
- */
-{
-/**
- * Map from a contact to it's reaction to message.
- */
-"reactionsByContact":Record<U32,(string)[]>;
-/**
- * Unique reactions and their count
- */
-"reactions":Record<string,U32>;};
-export type Message={"id":U32;"chatId":U32;"fromId":U32;"quote":(MessageQuote|null);"parentId":(U32|null);"text":(string|null);"hasLocation":boolean;"hasHtml":boolean;"viewType":Viewtype;"state":U32;"timestamp":I64;"sortTimestamp":I64;"receivedTimestamp":I64;"hasDeviatingTimestamp":boolean;"subject":string;"showPadlock":boolean;"isSetupmessage":boolean;"isInfo":boolean;"isForwarded":boolean;
-/**
- * when is_info is true this describes what type of system message it is
- */
-"systemMessageType":SystemMessageType;"duration":I32;"dimensionsHeight":I32;"dimensionsWidth":I32;"videochatType":(U32|null);"videochatUrl":(string|null);"overrideSenderName":(string|null);"sender":Contact;"setupCodeBegin":(string|null);"file":(string|null);"fileMime":(string|null);"fileBytes":U64;"fileName":(string|null);"webxdcInfo":(WebxdcMessageInfo|null);"downloadState":DownloadState;"reactions":(Reactions|null);};
-export type MessageNotificationInfo={"id":U32;"chatId":U32;"accountId":U32;"image":(string|null);"imageMimeType":(string|null);"chatName":string;"chatProfileImage":(string|null);
-/**
- * also known as summary_text1
- */
-"summaryPrefix":(string|null);
-/**
- * also known as summary_text2
- */
-"summaryText":string;};
-export type MessageSearchResult={"id":U32;"authorProfileImage":(string|null);"authorName":string;"authorColor":string;"chatName":(string|null);"message":string;"timestamp":I64;};
-export type F64=number;
-export type Location={"locationId":U32;"isIndependent":boolean;"latitude":F64;"longitude":F64;"accuracy":F64;"timestamp":I64;"contactId":U32;"msgId":U32;"chatId":U32;"marker":(string|null);};
-export type __AllTyps=[string,boolean,Record<string,string>,U32,U32,null,(U32)[],U32,null,(U32|null),(Account)[],null,null,U32,null,U32,null,U32,Account,U32,U64,U32,string,(ProviderInfo|null),U32,boolean,U32,Record<string,string>,U32,string,(string|null),null,U32,Record<string,(string|null)>,null,U32,string,null,U32,string,Qr,U32,string,(string|null),U32,(string)[],Record<string,(string|null)>,Record<U32,string>,null,U32,null,U32,null,U32,string,(string|null),null,U32,string,(string|null),null,U32,(U32)[],U32,U32,Usize,U32,boolean,I64,Usize,U32,string,U32,U32,string,null,U32,(U32|null),(string|null),(U32|null),(ChatListEntry)[],U32,(ChatListEntry)[],Record<U32,ChatListItemFetchResult>,U32,U32,FullChat,U32,U32,BasicChat,U32,U32,null,U32,U32,null,U32,U32,null,U32,U32,string,U32,(U32|null),[string,string],U32,string,U32,U32,U32,null,U32,U32,U32,null,U32,U32,U32,null,U32,U32,(U32)[],U32,string,boolean,U32,U32,U32,U32,U32,string,null,U32,U32,(string|null),null,U32,U32,ChatVisibility,null,U32,U32,U32,null,U32,U32,U32,U32,string,string,U32,U32,U32,null,U32,U32,(U32|null),U32,U32,MuteDuration,null,U32,U32,boolean,U32,(U32)[],null,U32,U32,U32,(U32)[],U32,U32,U32,(MessageListItem)[],U32,U32,Message,U32,U32,(string|null),U32,(U32)[],Record<U32,Message>,U32,U32,MessageNotificationInfo,U32,(U32)[],null,U32,U32,string,U32,U32,null,U32,string,(U32|null),(U32)[],U32,(U32)[],Record<U32,MessageSearchResult>,U32,U32,Contact,U32,string,(string|null),U32,U32,U32,U32,U32,U32,null,U32,U32,null,U32,(Contact)[],U32,U32,(string|null),(U32)[],U32,U32,(string|null),(Contact)[],U32,(U32)[],Record<U32,Contact>,U32,U32,boolean,U32,U32,string,null,U32,U32,string,U32,string,(U32|null),U32,(U32|null),Viewtype,(Viewtype|null),(Viewtype|null),(U32)[],U32,U32,Viewtype,(Viewtype|null),(Viewtype|null),[(U32|null),(U32|null)],U32,string,(string|null),null,U32,string,(string|null),null,null,U32,U32,U32,string,U32,(U32|null),(U32|null),I64,I64,(Location)[],U32,U32,string,string,null,U32,U32,U32,string,U32,U32,WebxdcMessageInfo,U32,(U32)[],U32,null,U32,U32,string,U32,U32,U32,(string)[],U32,U32,U32,null,U32,U32,(Message|null),U32,U32,U32,U32,string,U32,U32,string,null,U32,Record<string,(string)[]>,U32,U32,string,U32,U32,U32,(string|null),(string|null),([F64,F64]|null),(U32|null),[U32,Message],U32,U32,(string|null),(string|null),(U32|null),null];

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.102.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

@@ -12,39 +12,39 @@ describe("online tests", function () {
   let accountId1: number, accountId2: number;
 
   before(async function () {
-    this.timeout(12000);
-    if (!process.env.DCC_NEW_TMP_EMAIL) {
+    this.timeout(60000);
+    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-ratelimit/Cargo.toml

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

deltachat-ratelimit/src/lib.rs

@@ -7,7 +7,7 @@
 use std::time::{Duration, SystemTime};
 
 #[derive(Debug)]
-pub(crate) struct Ratelimit {
+pub struct Ratelimit {
     /// Time of the last update.
     last_update: SystemTime,
 
@@ -25,7 +25,7 @@ impl Ratelimit {
     /// Returns a new rate limiter with the given constraints.
     ///
     /// Rate limiter will allow to send no more than `quota` messages within duration `window`.
-    pub(crate) fn new(window: Duration, quota: f64) -> Self {
+    pub fn new(window: Duration, quota: f64) -> Self {
         Self::new_at(window, quota, SystemTime::now())
     }
 
@@ -57,7 +57,7 @@ impl Ratelimit {
     /// Returns true if can send another message now.
     ///
     /// This method takes mutable reference
-    pub(crate) fn can_send(&self) -> bool {
+    pub fn can_send(&self) -> bool {
         self.can_send_at(SystemTime::now())
     }
 
@@ -71,7 +71,7 @@ impl Ratelimit {
     /// It is possible to send message even if over quota, e.g. if the message sending is initiated
     /// by the user and should not be rate limited. However, sending messages when over quota
     /// further postpones the time when it will be allowed to send low priority messages.
-    pub(crate) fn send(&mut self) {
+    pub fn send(&mut self) {
         self.send_at(SystemTime::now())
     }
 
@@ -87,7 +87,7 @@ impl Ratelimit {
     }
 
     /// Calculates the time until `can_send` will return `true`.
-    pub(crate) fn until_can_send(&self) -> Duration {
+    pub fn until_can_send(&self) -> Duration {
         self.until_can_send_at(SystemTime::now())
     }
 }

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

@@ -0,0 +1,50 @@
+# Delta Chat RPC python client
+
+RPC client connects to standalone Delta Chat RPC server `deltachat-rpc-server`
+and provides asynchronous interface to it.
+
+## Getting started
+
+To use Delta Chat RPC client, first build a `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`
+or download a prebuilt release.
+Install it anywhere in your `PATH`.
+
+[Create a virtual environment](https://docs.python.org/3/library/venv.html)
+if you don't have one already and activate it.
+```
+$ python -m venv env
+$ . env/bin/activate
+```
+
+Install `deltachat-rpc-client` from source:
+```
+$ cd deltachat-rpc-client
+$ pip install .
+```
+
+## Testing
+
+1. Build `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`.
+2. Run `PATH="../target/debug:$PATH" tox`.
+
+Additional arguments to `tox` are passed to pytest, e.g. `tox -- -s` does not capture test output.
+
+## Using in REPL
+
+Setup a development environment:
+```
+$ tox --devenv env
+$ . env/bin/activate
+```
+
+```
+$ 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

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Minimal echo bot example.
+
+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.
+"""
+from deltachat_rpc_client import events, run_bot_cli
+
+hooks = events.HookCollection()
+
+
+@hooks.on(events.RawEvent)
+def log_event(event):
+    print(event)
+
+
+@hooks.on(events.NewMessage)
+def echo(event):
+    snapshot = event.message_snapshot
+    snapshot.chat.send_text(snapshot.text)
+
+
+if __name__ == "__main__":
+    run_bot_cli(hooks)

deltachat-rpc-client/examples/echobot_advanced.py

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

deltachat-rpc-client/examples/echobot_no_hooks.py

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

deltachat-rpc-client/pyproject.toml

@@ -0,0 +1,73 @@
+[build-system]
+requires = ["setuptools>=45", "setuptools_scm[toml]>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "deltachat-rpc-client"
+description = "Python client for Delta Chat core JSON-RPC interface"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS :: MacOS X",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Communications :: Chat",
+    "Topic :: Communications :: Email"
+]
+dynamic = [
+    "version"
+]
+
+[tool.setuptools.package-data]
+deltachat_rpc_client = [
+    "py.typed"
+]
+
+[project.entry-points.pytest11]
+"deltachat_rpc_client.pytestplugin" = "deltachat_rpc_client.pytestplugin"
+
+[tool.setuptools_scm]
+root = ".."
+
+[tool.black]
+line-length = 120
+
+[tool.ruff]
+select = [
+  "E", "W", # pycodestyle
+  "F", # Pyflakes
+  "N", # pep8-naming
+  "I", # isort
+
+  "ARG", # flake8-unused-arguments
+  "B", # flake8-bugbear
+  "C4", # flake8-comprehensions
+  "COM", # flake8-commas
+  "DTZ", # flake8-datetimez
+  "ICN", # flake8-import-conventions
+  "ISC", # flake8-implicit-str-concat
+  "PIE", # flake8-pie
+  "PT", # flake8-pytest-style
+  "RET", # flake8-return
+  "SIM", # flake8-simplify
+  "TCH", # flake8-type-checking
+  "TID", # flake8-tidy-imports
+  "YTT", # flake8-2020
+
+  "ERA", # eradicate
+
+  "PLC", # Pylint Convention
+  "PLE", # Pylint Error
+  "PLW", # Pylint Warning
+
+  "RUF006" # asyncio-dangling-task
+]
+line-length = 120
+
+[tool.isort]
+profile = "black"

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

@@ -0,0 +1,26 @@
+"""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, SpecialContactId
+from .contact import Contact
+from .deltachat import DeltaChat
+from .message import Message
+from .rpc import Rpc
+
+__all__ = [
+    "Account",
+    "AttrDict",
+    "Bot",
+    "Chat",
+    "Client",
+    "Contact",
+    "DeltaChat",
+    "EventType",
+    "Message",
+    "SpecialContactId",
+    "Rpc",
+    "run_bot_cli",
+    "run_client_cli",
+]

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

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

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

@@ -0,0 +1,269 @@
+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
+
+if TYPE_CHECKING:
+    from .deltachat import DeltaChat
+    from .rpc import Rpc
+
+
+@dataclass
+class Account:
+    """Delta Chat account."""
+
+    manager: "DeltaChat"
+    id: int
+
+    @property
+    def _rpc(self) -> "Rpc":
+        return self.manager.rpc
+
+    def wait_for_event(self) -> AttrDict:
+        """Wait until the next event and return it."""
+        return AttrDict(self._rpc.wait_for_event(self.id))
+
+    def remove(self) -> None:
+        """Remove the account."""
+        self._rpc.remove_account(self.id)
+
+    def start_io(self) -> None:
+        """Start the account I/O."""
+        self._rpc.start_io(self.id)
+
+    def stop_io(self) -> None:
+        """Stop the account I/O."""
+        self._rpc.stop_io(self.id)
+
+    def get_info(self) -> AttrDict:
+        """Return dictionary of this account configuration parameters."""
+        return AttrDict(self._rpc.get_info(self.id))
+
+    def get_size(self) -> int:
+        """Get the combined filesize of an account in bytes."""
+        return self._rpc.get_account_file_size(self.id)
+
+    def is_configured(self) -> bool:
+        """Return True if this account is configured."""
+        return self._rpc.is_configured(self.id)
+
+    def set_config(self, key: str, value: Optional[str] = None) -> None:
+        """Set configuration value."""
+        self._rpc.set_config(self.id, key, value)
+
+    def get_config(self, key: str) -> Optional[str]:
+        """Get configuration value."""
+        return self._rpc.get_config(self.id, key)
+
+    def update_config(self, **kwargs) -> None:
+        """update config values."""
+        for key, value in kwargs.items():
+            self.set_config(key, value)
+
+    def set_avatar(self, img_path: Optional[str] = None) -> None:
+        """Set self avatar.
+
+        Passing None will discard the currently set avatar.
+        """
+        self.set_config("selfavatar", img_path)
+
+    def get_avatar(self) -> Optional[str]:
+        """Get self avatar."""
+        return self.get_config("selfavatar")
+
+    def configure(self) -> None:
+        """Configure an account."""
+        self._rpc.configure(self.id)
+
+    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
+        underlying contact id.  If there already is a Contact
+        with that e-mail address, it is unblocked and its display
+        name is updated if specified.
+
+        :param obj: email-address or contact id.
+        :param name: (optional) display name for this contact.
+        """
+        if isinstance(obj, int):
+            obj = Contact(self, obj)
+        if isinstance(obj, Contact):
+            obj = obj.get_snapshot().address
+        return Contact(self, self._rpc.create_contact(self.id, obj, name))
+
+    def get_contact_by_id(self, contact_id: int) -> Contact:
+        """Return Contact instance for the given contact ID."""
+        return Contact(self, contact_id)
+
+    def get_contact_by_addr(self, address: str) -> Optional[Contact]:
+        """Check if an e-mail address belongs to a known and unblocked contact."""
+        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
+        return contact_id and Contact(self, contact_id)
+
+    def get_blocked_contacts(self) -> List[AttrDict]:
+        """Return a list with snapshots of all blocked contacts."""
+        contacts = self._rpc.get_blocked_contacts(self.id)
+        return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
+
+    def get_contacts(
+        self,
+        query: Optional[str] = None,
+        with_self: bool = False,
+        verified_only: bool = False,
+        snapshot: bool = False,
+    ) -> Union[List[Contact], List[AttrDict]]:
+        """Get a filtered list of contacts.
+
+        :param query: if a string is specified, only return contacts
+                      whose name or e-mail matches query.
+        :param with_self: if True the self-contact is also included if it matches the query.
+        :param only_verified: if True only return verified contacts.
+        :param snapshot: If True return a list of contact snapshots instead of Contact instances.
+        """
+        flags = 0
+        if verified_only:
+            flags |= ContactFlag.VERIFIED_ONLY
+        if with_self:
+            flags |= ContactFlag.ADD_SELF
+
+        if snapshot:
+            contacts = self._rpc.get_contacts(self.id, flags, query)
+            return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
+        contacts = self._rpc.get_contact_ids(self.id, flags, query)
+        return [Contact(self, contact_id) for contact_id in contacts]
+
+    @property
+    def self_contact(self) -> Contact:
+        """This account's identity as a Contact."""
+        return Contact(self, SpecialContactId.SELF)
+
+    def get_chatlist(
+        self,
+        query: Optional[str] = None,
+        contact: Optional[Contact] = None,
+        archived_only: bool = False,
+        for_forwarding: bool = False,
+        no_specials: bool = False,
+        alldone_hint: bool = False,
+        snapshot: bool = False,
+    ) -> Union[List[Chat], List[AttrDict]]:
+        """Return list of chats.
+
+        :param query: if a string is specified only chats matching this query are returned.
+        :param contact: if a contact is specified only chats including this contact are returned.
+        :param archived_only: if True only archived chats are returned.
+        :param for_forwarding: if True the chat list is sorted with "Saved messages" at the top
+                               and without "Device chat" and contact requests.
+        :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.
+        :param snapshot: If True return a list of chat snapshots instead of Chat instances.
+        """
+        flags = 0
+        if archived_only:
+            flags |= ChatlistFlag.ARCHIVED_ONLY
+        if for_forwarding:
+            flags |= ChatlistFlag.FOR_FORWARDING
+        if no_specials:
+            flags |= ChatlistFlag.NO_SPECIALS
+        if alldone_hint:
+            flags |= ChatlistFlag.ADD_ALLDONE_HINT
+
+        entries = self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
+        if not snapshot:
+            return [Chat(self, entry) for entry in 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
+
+    def create_group(self, name: str, protect: bool = False) -> Chat:
+        """Create a new group chat.
+
+        After creation, the group has only self-contact as member and is in unpromoted state.
+        """
+        return Chat(self, self._rpc.create_group_chat(self.id, name, protect))
+
+    def get_chat_by_id(self, chat_id: int) -> Chat:
+        """Return the Chat instance with the given ID."""
+        return Chat(self, chat_id)
+
+    def secure_join(self, qrdata: str) -> Chat:
+        """Continue a Setup-Contact or Verified-Group-Invite protocol started on
+        another device.
+
+        The function returns immediately and the handshake runs in background, sending
+        and receiving several messages.
+        Subsequent calls of `secure_join()` will abort previous, unfinished handshakes.
+        See https://countermitm.readthedocs.io/en/latest/new.html for protocol details.
+
+        :param qrdata: The text of the scanned QR code.
+        """
+        return Chat(self, self._rpc.secure_join(self.id, qrdata))
+
+    def get_qr_code(self) -> Tuple[str, str]:
+        """Get Setup-Contact QR Code text and SVG data.
+
+        this data needs to be transferred to another Delta Chat account
+        in a second channel, typically used by mobiles with QRcode-show + scan UX.
+        """
+        return self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
+
+    def get_message_by_id(self, msg_id: int) -> Message:
+        """Return the Message instance with the given ID."""
+        return Message(self, msg_id)
+
+    def mark_seen_messages(self, messages: List[Message]) -> None:
+        """Mark the given set of messages as seen."""
+        self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
+
+    def delete_messages(self, messages: List[Message]) -> None:
+        """Delete messages (local and remote)."""
+        self._rpc.delete_messages(self.id, [msg.id for msg in messages])
+
+    def get_fresh_messages(self) -> List[Message]:
+        """Return the list of fresh messages, newest messages first.
+
+        This call is intended for displaying notifications.
+        If you are writing a bot, use `get_fresh_messages_in_arrival_order()` instead,
+        to process oldest messages first.
+        """
+        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
+        return [Message(self, msg_id) for msg_id in fresh_msg_ids]
+
+    def get_next_messages(self) -> List[Message]:
+        """Return a list of next messages."""
+        next_msg_ids = self._rpc.get_next_msgs(self.id)
+        return [Message(self, msg_id) for msg_id in next_msg_ids]
+
+    def wait_next_messages(self) -> List[Message]:
+        """Wait for new messages and return a list of them."""
+        next_msg_ids = self._rpc.wait_next_msgs(self.id)
+        return [Message(self, msg_id) for msg_id in next_msg_ids]
+
+    def get_fresh_messages_in_arrival_order(self) -> List[Message]:
+        """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
+        warn(
+            "get_fresh_messages_in_arrival_order is deprecated, use get_next_messages instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        fresh_msg_ids = sorted(self._rpc.get_fresh_msgs(self.id))
+        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

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

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

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

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

@@ -0,0 +1,124 @@
+from enum import Enum, IntEnum
+
+COMMAND_PREFIX = "/"
+
+
+class ContactFlag(IntEnum):
+    VERIFIED_ONLY = 0x01
+    ADD_SELF = 0x02
+
+
+class ChatlistFlag(IntEnum):
+    ARCHIVED_ONLY = 0x01
+    NO_SPECIALS = 0x02
+    ADD_ALLDONE_HINT = 0x04
+    FOR_FORWARDING = 0x08
+
+
+class SpecialContactId(IntEnum):
+    SELF = 1
+    INFO = 2  # centered messages as "member added", used in all chats
+    DEVICE = 5  #  messages "update info" in the device-chat
+    LAST_SPECIAL = 9
+
+
+class EventType(str, Enum):
+    """Core event types"""
+
+    INFO = "Info"
+    SMTP_CONNECTED = "SmtpConnected"
+    IMAP_CONNECTED = "ImapConnected"
+    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"
+    ERROR = "Error"
+    ERROR_SELF_NOT_IN_GROUP = "ErrorSelfNotInGroup"
+    MSGS_CHANGED = "MsgsChanged"
+    REACTIONS_CHANGED = "ReactionsChanged"
+    INCOMING_MSG = "IncomingMsg"
+    INCOMING_MSG_BUNCH = "IncomingMsgBunch"
+    MSGS_NOTICED = "MsgsNoticed"
+    MSG_DELIVERED = "MsgDelivered"
+    MSG_FAILED = "MsgFailed"
+    MSG_READ = "MsgRead"
+    MSG_DELETED = "MsgDeleted"
+    CHAT_MODIFIED = "ChatModified"
+    CHAT_EPHEMERAL_TIMER_MODIFIED = "ChatEphemeralTimerModified"
+    CONTACTS_CHANGED = "ContactsChanged"
+    LOCATION_CHANGED = "LocationChanged"
+    CONFIGURE_PROGRESS = "ConfigureProgress"
+    IMEX_PROGRESS = "ImexProgress"
+    IMEX_FILE_WRITTEN = "ImexFileWritten"
+    SECUREJOIN_INVITER_PROGRESS = "SecurejoinInviterProgress"
+    SECUREJOIN_JOINER_PROGRESS = "SecurejoinJoinerProgress"
+    CONNECTIVITY_CHANGED = "ConnectivityChanged"
+    SELFAVATAR_CHANGED = "SelfavatarChanged"
+    WEBXDC_STATUS_UPDATE = "WebxdcStatusUpdate"
+    WEBXDC_INSTANCE_DELETED = "WebxdcInstanceDeleted"
+
+
+class ChatType(IntEnum):
+    """Chat types"""
+
+    UNDEFINED = 0
+    SINGLE = 100
+    GROUP = 120
+    MAILINGLIST = 140
+    BROADCAST = 160
+
+
+class ChatVisibility(str, Enum):
+    """Chat visibility types"""
+
+    NORMAL = "Normal"
+    ARCHIVED = "Archived"
+    PINNED = "Pinned"
+
+
+class DownloadState(str, Enum):
+    """Message download state"""
+
+    DONE = "Done"
+    AVAILABLE = "Available"
+    FAILURE = "Failure"
+    IN_PROGRESS = "InProgress"
+
+
+class ViewType(str, Enum):
+    """Message view type."""
+
+    UNKNOWN = "Unknown"
+    TEXT = "Text"
+    IMAGE = "Image"
+    GIF = "Gif"
+    STICKER = "Sticker"
+    AUDIO = "Audio"
+    VOICE = "Voice"
+    VIDEO = "Video"
+    FILE = "File"
+    VIDEOCHAT_INVITATION = "VideochatInvitation"
+    WEBXDC = "Webxdc"
+
+
+class SystemMessageType(str, Enum):
+    """System message type."""
+
+    UNKNOWN = "Unknown"
+    GROUP_NAME_CHANGED = "GroupNameChanged"
+    GROUP_IMAGE_CHANGED = "GroupImageChanged"
+    MEMBER_ADDED_TO_GROUP = "MemberAddedToGroup"
+    MEMBER_REMOVED_FROM_GROUP = "MemberRemovedFromGroup"
+    AUTOCRYPT_SETUP_MESSAGE = "AutocryptSetupMessage"
+    SECUREJOIN_MESSAGE = "SecurejoinMessage"
+    LOCATION_STREAMING_ENABLED = "LocationStreamingEnabled"
+    LOCATION_ONLY = "LocationOnly"
+    CHAT_PROTECTION_ENABLED = "ChatProtectionEnabled"
+    CHAT_PROTECTION_DISABLED = "ChatProtectionDisabled"
+    WEBXDC_STATUS_UPDATE = "WebxdcStatusUpdate"
+    EPHEMERAL_TIMER_CHANGED = "EphemeralTimerChanged"
+    MULTI_DEVICE_SYNC = "MultiDeviceSync"
+    WEBXDC_INFO_MESSAGE = "WebxdcInfoMessage"

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

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

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

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

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

@@ -0,0 +1,280 @@
+"""High-level classes for event processing and filtering."""
+import re
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Set, Tuple, Union
+
+from .const import EventType
+
+if TYPE_CHECKING:
+    from ._utils import AttrDict
+
+
+def _tuple_of(obj, type_: type) -> tuple:
+    if not obj:
+        return ()
+    if isinstance(obj, type_):
+        obj = (obj,)
+
+    if not all(isinstance(elem, type_) for elem in obj):
+        raise TypeError()
+    return tuple(obj)
+
+
+class EventFilter(ABC):
+    """The base event filter.
+
+    :param func: A Callable function that should accept the event as input
+                 parameter, and return a bool value indicating whether the event
+                 should be dispatched or not.
+    """
+
+    def __init__(self, func: Optional[Callable] = None):
+        self.func = func
+
+    @abstractmethod
+    def __hash__(self) -> int:
+        """Object's unique hash"""
+
+    @abstractmethod
+    def __eq__(self, other) -> bool:
+        """Return True if two event filters are equal."""
+
+    def __ne__(self, other):
+        return not self == other
+
+    def _call_func(self, event) -> bool:
+        if not self.func:
+            return True
+        return self.func(event)
+
+    @abstractmethod
+    def filter(self, event):
+        """Return True-like value if the event passed the filter and should be
+        used, or False-like value otherwise.
+        """
+
+
+class RawEvent(EventFilter):
+    """Matches raw core events.
+
+    :param types: The types of event to match.
+    :param func: A Callable function that should accept the event as input
+                 parameter, and return a bool value indicating whether the event
+                 should be dispatched or not.
+    """
+
+    def __init__(self, types: Union[None, EventType, Iterable[EventType]] = None, **kwargs):
+        super().__init__(**kwargs)
+        try:
+            self.types = _tuple_of(types, EventType)
+        except TypeError as err:
+            raise TypeError(f"Invalid event type given: {types}") from err
+
+    def __hash__(self) -> int:
+        return hash((self.types, self.func))
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, RawEvent):
+            return (self.types, self.func) == (other.types, other.func)
+        return False
+
+    def filter(self, event: "AttrDict") -> bool:
+        if self.types and event.kind not in self.types:
+            return False
+        return self._call_func(event)
+
+
+class NewMessage(EventFilter):
+    """Matches whenever a new message arrives.
+
+    Warning: registering a handler for this event will cause the messages
+    to be marked as read. Its usage is mainly intended for bots.
+
+    :param pattern: if set, this Pattern will be used to filter the message by its text
+                    content.
+    :param command: If set, only match messages with the given command (ex. /help).
+                    Setting this property implies `is_info==False`.
+    :param is_bot: If set to True only match messages sent by bots, if set to None
+                   match messages from bots and users. If omitted or set to False
+                   only messages from users will be matched.
+    :param is_info: If set to True only match info/system messages, if set to False
+                    only match messages that are not info/system messages. If omitted
+                    info/system messages as well as normal messages will be matched.
+    :param func: A Callable function that should accept the event as input
+                 parameter, and return a bool value indicating whether the event
+                 should be dispatched or not.
+    """
+
+    def __init__(
+        self,
+        pattern: Union[
+            None,
+            str,
+            Callable[[str], bool],
+            re.Pattern,
+        ] = None,
+        command: Optional[str] = None,
+        is_bot: Optional[bool] = False,
+        is_info: Optional[bool] = None,
+        func: Optional[Callable[["AttrDict"], bool]] = None,
+    ) -> None:
+        super().__init__(func=func)
+        self.is_bot = is_bot
+        self.is_info = is_info
+        if command is not None and not isinstance(command, str):
+            raise TypeError("Invalid command")
+        self.command = command
+        if self.is_info and self.command:
+            raise AttributeError("Can not use command and is_info at the same time.")
+        if isinstance(pattern, str):
+            pattern = re.compile(pattern)
+        if isinstance(pattern, re.Pattern):
+            self.pattern: Optional[Callable] = pattern.match
+        elif not pattern or callable(pattern):
+            self.pattern = pattern
+        else:
+            raise TypeError("Invalid pattern type")
+
+    def __hash__(self) -> int:
+        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_bot,
+                self.is_info,
+                self.func,
+            ) == (
+                other.pattern,
+                other.command,
+                other.is_bot,
+                other.is_info,
+                other.func,
+            )
+        return False
+
+    def filter(self, event: "AttrDict") -> bool:
+        if self.is_bot is not None and self.is_bot != event.message_snapshot.is_bot:
+            return False
+        if self.is_info is not None and self.is_info != event.message_snapshot.is_info:
+            return False
+        if self.command and self.command != event.command:
+            return False
+        if self.pattern:
+            match = self.pattern(event.message_snapshot.text)
+            if not match:
+                return False
+        return super()._call_func(event)
+
+
+class MemberListChanged(EventFilter):
+    """Matches when a group member is added or removed.
+
+    Warning: registering a handler for this event will cause the messages
+    to be marked as read. Its usage is mainly intended for bots.
+
+    :param added: If set to True only match if a member was added, if set to False
+                  only match if a member was removed. If omitted both, member additions
+                  and removals, will be matched.
+    :param func: A Callable function that should accept the event as input
+                 parameter, and return a bool value indicating whether the event
+                 should be dispatched or not.
+    """
+
+    def __init__(self, added: Optional[bool] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.added = added
+
+    def __hash__(self) -> int:
+        return hash((self.added, self.func))
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, MemberListChanged):
+            return (self.added, self.func) == (other.added, other.func)
+        return False
+
+    def filter(self, event: "AttrDict") -> bool:
+        if self.added is not None and self.added != event.member_added:
+            return False
+        return self._call_func(event)
+
+
+class GroupImageChanged(EventFilter):
+    """Matches when the group image is changed.
+
+    Warning: registering a handler for this event will cause the messages
+    to be marked as read. Its usage is mainly intended for bots.
+
+    :param deleted: If set to True only match if the image was deleted, if set to False
+                    only match if a new image was set. If omitted both, image changes and
+                    removals, will be matched.
+    :param func: A Callable function that should accept the event as input
+                 parameter, and return a bool value indicating whether the event
+                 should be dispatched or not.
+    """
+
+    def __init__(self, deleted: Optional[bool] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.deleted = deleted
+
+    def __hash__(self) -> int:
+        return hash((self.deleted, self.func))
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, GroupImageChanged):
+            return (self.deleted, self.func) == (other.deleted, other.func)
+        return False
+
+    def filter(self, event: "AttrDict") -> bool:
+        if self.deleted is not None and self.deleted != event.image_deleted:
+            return False
+        return self._call_func(event)
+
+
+class GroupNameChanged(EventFilter):
+    """Matches when the group name is changed.
+
+    Warning: registering a handler for this event will cause the messages
+    to be marked as read. Its usage is mainly intended for bots.
+
+    :param func: A Callable function that should accept the event as input
+                 parameter, and return a bool value indicating whether the event
+                 should be dispatched or not.
+    """
+
+    def __hash__(self) -> int:
+        return hash((GroupNameChanged, self.func))
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, GroupNameChanged):
+            return self.func == other.func
+        return False
+
+    def filter(self, event: "AttrDict") -> bool:
+        return self._call_func(event)
+
+
+class HookCollection:
+    """
+    Helper class to collect event hooks that can later be added to a Delta Chat client.
+    """
+
+    def __init__(self) -> None:
+        self._hooks: Set[Tuple[Callable, Union[type, EventFilter]]] = set()
+
+    def __iter__(self) -> Iterator[Tuple[Callable, Union[type, EventFilter]]]:
+        return iter(self._hooks)
+
+    def on(self, event: Union[type, EventFilter]) -> Callable:  # noqa
+        """Register decorated function as listener for the given event."""
+        if isinstance(event, type):
+            event = event()
+        assert isinstance(event, EventFilter), "Invalid event filter"
+
+        def _decorator(func) -> Callable:
+            self._hooks.add((func, event))
+            return func
+
+        return _decorator

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

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

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

@@ -0,0 +1 @@
+# PEP 561 marker file. See https://peps.python.org/pep-0561/

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

@@ -0,0 +1,108 @@
+import os
+import random
+from typing import AsyncGenerator, List, Optional
+
+import pytest
+
+from . import Account, AttrDict, Bot, Client, DeltaChat, EventType, Message
+from .rpc import Rpc
+
+
+def get_temp_credentials() -> dict:
+    domain = os.getenv("CHATMAIL_DOMAIN")
+    username = "ci-" + "".join(random.choice("2345789acdefghjkmnpqrstuvwxyz") for i in range(6))
+    password = f"{username}${username}"
+    addr = f"{username}@{domain}"
+    return {"email": addr, "password": password}
+
+
+class ACFactory:
+    def __init__(self, deltachat: DeltaChat) -> None:
+        self.deltachat = deltachat
+
+    def get_unconfigured_account(self) -> Account:
+        return self.deltachat.add_account()
+
+    def get_unconfigured_bot(self) -> Bot:
+        return Bot(self.get_unconfigured_account())
+
+    def new_preconfigured_account(self) -> Account:
+        """Make a new account with configuration options set, but configuration not started."""
+        credentials = get_temp_credentials()
+        account = self.get_unconfigured_account()
+        account.set_config("addr", credentials["email"])
+        account.set_config("mail_pw", credentials["password"])
+        assert not account.is_configured()
+        return account
+
+    def new_configured_account(self) -> Account:
+        account = self.new_preconfigured_account()
+        account.configure()
+        assert account.is_configured()
+        return account
+
+    def new_configured_bot(self) -> Bot:
+        credentials = get_temp_credentials()
+        bot = self.get_unconfigured_bot()
+        bot.configure(credentials["email"], credentials["password"])
+        return bot
+
+    def get_online_account(self) -> Account:
+        account = self.new_configured_account()
+        account.start_io()
+        while True:
+            event = account.wait_for_event()
+            if event.kind == EventType.IMAP_INBOX_IDLE:
+                break
+        return account
+
+    def get_online_accounts(self, num: int) -> List[Account]:
+        return [self.get_online_account() for _ in range(num)]
+
+    def send_message(
+        self,
+        to_account: Account,
+        from_account: Optional[Account] = None,
+        text: Optional[str] = None,
+        file: Optional[str] = None,
+        group: Optional[str] = None,
+    ) -> Message:
+        if not from_account:
+            from_account = (self.get_online_accounts(1))[0]
+        to_contact = from_account.create_contact(to_account.get_config("addr"))
+        if group:
+            to_chat = from_account.create_group(group)
+            to_chat.add_contact(to_contact)
+        else:
+            to_chat = to_contact.create_chat()
+        return to_chat.send_message(text=text, file=file)
+
+    def process_message(
+        self,
+        to_client: Client,
+        from_account: Optional[Account] = None,
+        text: Optional[str] = None,
+        file: Optional[str] = None,
+        group: Optional[str] = None,
+    ) -> AttrDict:
+        self.send_message(
+            to_account=to_client.account,
+            from_account=from_account,
+            text=text,
+            file=file,
+            group=group,
+        )
+
+        return to_client.run_until(lambda e: e.kind == EventType.INCOMING_MSG)
+
+
+@pytest.fixture()
+def rpc(tmp_path) -> AsyncGenerator:
+    rpc_server = Rpc(accounts_dir=str(tmp_path / "accounts"))
+    with rpc_server:
+        yield rpc_server
+
+
+@pytest.fixture()
+def acfactory(rpc) -> AsyncGenerator:
+    return ACFactory(DeltaChat(rpc))