Merge pull request #1543 from ton-blockchain/testnet

Merge developer branch

.clang_complete

@@ -1,5 +1,5 @@
 -xc++
--std=c++14
+-std=c++17
 -iquote .
 -iquote tdtl/
 -iquote tl/

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 2

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,13 @@
+<!-- Describe the issue -->
+<!--- What behavior did you expect? -->
+
+<!--- What was the actual behavior? -->
+
+<!--- How reliably can you reproduce the issue, what are the steps to do so? -->
+
+<!-- What version of TON are you using, where did you get it (github actions, self-compiled, etc)? -->
+
+<!-- What type of machine are you observing the error on (OS/CPU and disk type)? -->
+
+<!-- Any extra information that might be useful in the debugging process. -->
+<!--- This is normally the contents of a `debug.log` or `config.log` file. Raw text or a link to a pastebin type site are preferred. -->

.github/workflows/build-ton-linux-android-tonlib.yml

@@ -0,0 +1,34 @@
+name: Tonlib Android
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+      with:      
+        submodules: 'recursive'
+
+    - name: Install system libraries
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential git cmake ninja-build automake libtool texinfo autoconf libgflags-dev \
+        zlib1g-dev libssl-dev libreadline-dev libmicrohttpd-dev pkg-config libgsl-dev python3 python3-dev \
+        libtool autoconf libsodium-dev libsecp256k1-dev liblz4-dev
+
+    - name: Build TON
+      run: |
+        git submodule sync --recursive
+        git submodule update
+        cp assembly/android/build-android-tonlib.sh .
+        chmod +x build-android-tonlib.sh
+        ./build-android-tonlib.sh -a
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@master
+      with:
+        name: ton-android-tonlib
+        path: artifacts

.github/workflows/build-ton-linux-arm64-appimage.yml

@@ -0,0 +1,57 @@
+name: Ubuntu TON build (AppImages, arm64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04-arm
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+      with:      
+        submodules: 'recursive'
+
+    - name: Install system libraries
+      run: |
+        sudo apt update
+        sudo apt install -y build-essential git cmake ninja-build zlib1g-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev liblz4-dev
+        sudo apt remove libgsl-dev
+
+    - name: Install clang-16
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x llvm.sh
+        sudo ./llvm.sh 16 all
+
+    - name: Build TON
+      run: |
+        git submodule sync --recursive
+        git submodule update
+        cp assembly/native/build-ubuntu-appimages.sh .
+        chmod +x build-ubuntu-appimages.sh
+        ./build-ubuntu-appimages.sh -a
+
+    - name: Make AppImages
+      run: |
+        cp assembly/appimage/create-appimages.sh .
+        cp assembly/appimage/AppRun .
+        cp assembly/appimage/ton.png .
+        chmod +x create-appimages.sh
+        ./create-appimages.sh aarch64
+        rm -rf artifacts
+
+
+    - name: Build TON libs
+      run: |
+        cp assembly/native/build-ubuntu-portable-libs.sh .
+        chmod +x build-ubuntu-portable-libs.sh
+        ./build-ubuntu-portable-libs.sh -a
+        cp ./artifacts/libtonlibjson.so appimages/artifacts/
+        cp ./artifacts/libemulator.so appimages/artifacts/
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@master
+      with:
+        name: ton-arm64-linux
+        path: appimages/artifacts

.github/workflows/build-ton-linux-arm64-shared.yml

@@ -0,0 +1,43 @@
+name: Ubuntu TON build (shared, arm64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04-arm, ubuntu-24.04-arm]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+      with:      
+        submodules: 'recursive'
+
+    - name: Install system libraries
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential git cmake ninja-build zlib1g-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev liblz4-dev libjemalloc-dev
+
+    - if: matrix.os != 'ubuntu-24.04-arm'
+      name: Install llvm-16
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x llvm.sh
+        sudo ./llvm.sh 16 all
+
+    - name: Build TON
+      run: |
+        git submodule sync --recursive
+        git submodule update
+        cp assembly/native/build-ubuntu-shared.sh .
+        chmod +x build-ubuntu-shared.sh
+        ./build-ubuntu-shared.sh -t -a
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@master
+      with:
+        name: ton-binaries-${{ matrix.os }}
+        path: artifacts

.github/workflows/build-ton-linux-x86-64-appimage.yml

@@ -0,0 +1,63 @@
+name: Ubuntu TON build (AppImages, x86-64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+      with:      
+        submodules: 'recursive'
+
+    - name: Install system libraries
+      run: |
+        sudo apt update
+        sudo apt install -y build-essential git cmake ninja-build zlib1g-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev liblz4-dev
+        sudo apt remove libgsl-dev
+
+    - name: Install gcc-11 g++-11
+      run: |
+        sudo apt install -y manpages-dev software-properties-common
+        sudo add-apt-repository ppa:ubuntu-toolchain-r/test
+        sudo apt update && sudo apt install gcc-11 g++-11
+
+    - name: Install clang-16
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x llvm.sh
+        sudo ./llvm.sh 16 all
+
+    - name: Build TON
+      run: |
+        git submodule sync --recursive
+        git submodule update
+        cp assembly/native/build-ubuntu-appimages.sh .
+        chmod +x build-ubuntu-appimages.sh
+        ./build-ubuntu-appimages.sh -a
+
+    - name: Make AppImages
+      run: |
+        cp assembly/appimage/create-appimages.sh .
+        cp assembly/appimage/AppRun .
+        cp assembly/appimage/ton.png .
+        chmod +x create-appimages.sh
+        ./create-appimages.sh x86_64
+        rm -rf artifacts
+
+
+    - name: Build TON libs
+      run: |
+        cp assembly/native/build-ubuntu-portable-libs.sh .
+        chmod +x build-ubuntu-portable-libs.sh
+        ./build-ubuntu-portable-libs.sh -a
+        cp ./artifacts/libtonlibjson.so appimages/artifacts/
+        cp ./artifacts/libemulator.so appimages/artifacts/
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@master
+      with:
+        name: ton-x86_64-linux
+        path: appimages/artifacts

.github/workflows/build-ton-linux-x86-64-shared.yml

@@ -0,0 +1,48 @@
+name: Ubuntu TON build (shared, x86-64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+      with:      
+        submodules: 'recursive'
+
+    - name: Install system libraries
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential git cmake ninja-build zlib1g-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev liblz4-dev libjemalloc-dev
+
+    - if: matrix.os == 'ubuntu-20.04'
+      run: |
+        sudo apt install -y manpages-dev software-properties-common
+        sudo add-apt-repository ppa:ubuntu-toolchain-r/test
+        sudo apt update && sudo apt install gcc-11 g++-11
+
+    - if: matrix.os != 'ubuntu-24.04'
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x llvm.sh
+        sudo ./llvm.sh 16 all
+
+    - name: Build TON
+      run: |
+        git submodule sync --recursive
+        git submodule update
+        cp assembly/native/build-ubuntu-shared.sh .
+        chmod +x build-ubuntu-shared.sh
+        ./build-ubuntu-shared.sh -t -a
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@master
+      with:
+        name: ton-binaries-${{ matrix.os }}
+        path: artifacts

.github/workflows/build-ton-macos-13-x86-64-portable.yml

@@ -0,0 +1,27 @@
+name: MacOS-13 TON build (portable, x86-64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: macos-13
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Build TON
+        run: |
+          git submodule sync --recursive
+          git submodule update
+          cp assembly/native/build-macos-portable.sh .
+          chmod +x build-macos-portable.sh
+          ./build-macos-portable.sh -t -a
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@master
+        with:
+          name: ton-x86_64-macos
+          path: artifacts

.github/workflows/build-ton-macos-14-arm64-portable.yml

@@ -0,0 +1,27 @@
+name: MacOS-14 TON build (portable, arm64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: macos-14
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Build TON
+        run: |
+          git submodule sync --recursive
+          git submodule update
+          cp assembly/native/build-macos-portable.sh .
+          chmod +x build-macos-portable.sh
+          ./build-macos-portable.sh -t -a
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@master
+        with:
+          name: ton-arm64-macos
+          path: artifacts

.github/workflows/build-ton-macos-15-arm64-shared.yml

@@ -0,0 +1,27 @@
+name: MacOS-15 TON build (shared, arm64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: macos-15
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Build TON
+        run: |
+          git submodule sync --recursive
+          git submodule update
+          cp assembly/native/build-macos-shared.sh .
+          chmod +x build-macos-shared.sh
+          ./build-macos-shared.sh -t -a
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@master
+        with:
+          name: ton-binaries-macos-15
+          path: artifacts

.github/workflows/build-ton-macos-arm64-shared.yml

@@ -0,0 +1,27 @@
+name: MacOS-14 TON build (shared, arm64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: macos-14
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Build TON
+        run: |
+          git submodule sync --recursive
+          git submodule update
+          cp assembly/native/build-macos-shared.sh .
+          chmod +x build-macos-shared.sh
+          ./build-macos-shared.sh -t -a
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@master
+        with:
+          name: ton-binaries-macos-14
+          path: artifacts

.github/workflows/build-ton-macos-x86-64-shared.yml

@@ -0,0 +1,27 @@
+name: MacOS TON build (shared, x86-64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: macos-13
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Build TON
+        run: |
+          git submodule sync --recursive
+          git submodule update
+          cp assembly/native/build-macos-shared.sh .
+          chmod +x build-macos-shared.sh
+          ./build-macos-shared.sh -t -a
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@master
+        with:
+          name: ton-binaries-macos-13
+          path: artifacts

.github/workflows/build-ton-wasm-emscripten.yml

@@ -0,0 +1,51 @@
+name: Emscripten TON build (wasm)
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+      with:
+        submodules: 'recursive'
+
+    - name: Install system libraries
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential git openssl cmake ninja-build zlib1g-dev libssl-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev liblz4-dev libjemalloc-dev
+
+    - name: Build TON WASM artifacts
+      run: |
+        git submodule sync --recursive
+        git submodule update
+        cp assembly/wasm/fift-func-wasm-build-ubuntu.sh .
+        chmod +x fift-func-wasm-build-ubuntu.sh
+        ./fift-func-wasm-build-ubuntu.sh -a
+
+    - name: Prepare test
+      run: |
+        cp assembly/wasm/*.fc .
+        git clone https://github.com/ton-community/func-js.git
+        cd func-js        
+        npm install
+        npm run build
+        npm link
+
+    - name: Test TON WASM artifacts
+      run: |
+        base64 -w 0 artifacts/funcfiftlib.wasm > artifacts/funcfiftlib.wasm.js
+        printf "module.exports = { FuncFiftLibWasm: '" | cat - artifacts/funcfiftlib.wasm.js > temp.txt && mv temp.txt artifacts/funcfiftlib.wasm.js
+        echo "'}" >> artifacts/funcfiftlib.wasm.js
+        cp artifacts/funcfiftlib.wasm.js func-js/node_modules/@ton-community/func-js-bin/dist/funcfiftlib.wasm.js
+        cp artifacts/funcfiftlib.js func-js/node_modules/@ton-community/func-js-bin/dist/funcfiftlib.js
+        npx func-js stdlib.fc intrinsics.fc --fift ./output.f
+    
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@master
+      with:
+        name: ton-wasm
+        path: artifacts

.github/workflows/create-release.yml

@@ -0,0 +1,730 @@
+name: Create release
+
+on: [workflow_dispatch]
+
+permissions: write-all
+
+env:
+  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+jobs:
+  create-release:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Download Linux arm64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-linux-arm64-appimage.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Download and unzip Linux arm64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-linux-arm64-appimage.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download Linux x86-64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-linux-x86-64-appimage.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Download and unzip Linux x86-64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-linux-x86-64-appimage.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download Mac x86-64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-macos-13-x86-64-portable.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Download Mac arm64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-macos-14-arm64-portable.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Download and unzip Mac x86-64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-macos-13-x86-64-portable.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download and unzip arm64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-macos-14-arm64-portable.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download Windows artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: ton-x86-64-windows.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Download and unzip Windows artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: ton-x86-64-windows.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download WASM artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-wasm-emscripten.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Download Android Tonlib artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-linux-android-tonlib.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Show all artifacts
+        run: |
+          tree artifacts
+      
+
+      # create release
+
+      - name: Read Changelog.md and use it as a body of new release
+        id: read_release
+        shell: bash
+        run: |
+          r=$(cat recent_changelog.md)
+          r="${r//'%'/'%25'}"
+          r="${r//$'\n'/'%0A'}"
+          r="${r//$'\r'/'%0D'}"
+          echo "::set-output name=CHANGELOG_BODY::$r"
+
+      - name: Get next tag
+        id: tag
+        run: |
+          git fetch --all --tags
+          git tag -l
+          NEW_TAG=v$(date +'%Y.%m')
+          FOUND=$(git tag -l | grep $NEW_TAG | wc -l)
+          if [ $FOUND -eq 0 ]; then
+            echo "TAG=$NEW_TAG" >> $GITHUB_OUTPUT
+          else
+            echo "TAG=$NEW_TAG-$FOUND" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Get registration token
+        id: getRegToken
+        run: |
+          curl -X POST -H \"Accept: application/vnd.github+json\"  -H 'Authorization: token ${{ secrets.GITHUB_TOKEN }}' https://api.github.com/repos/ton-blockchain/ton/actions/runners/registration-token
+
+      - name: Create release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.tag.outputs.TAG }}
+          release_name: TON ${{ steps.tag.outputs.TAG }}
+          body: |
+            ${{ steps.read_release.outputs.CHANGELOG_BODY }}
+          draft: false
+          prerelease: false
+
+      # upload
+
+      # win
+
+      - name: Upload Windows 2019 artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows.zip
+          asset_name: ton-win-x86-64.zip
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - fift
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/fift.exe
+          asset_name: fift.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - func
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/func.exe
+          asset_name: func.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/tolk.exe
+          asset_name: tolk.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - lite-client
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/lite-client.exe
+          asset_name: lite-client.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - proxy-liteserver
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/proxy-liteserver.exe
+          asset_name: proxy-liteserver.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - rldp-http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/rldp-http-proxy.exe
+          asset_name: rldp-http-proxy.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/http-proxy.exe
+          asset_name: http-proxy.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - storage-daemon-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/storage-daemon-cli.exe
+          asset_name: storage-daemon-cli.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - storage-daemon
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/storage-daemon.exe
+          asset_name: storage-daemon.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - tonlibjson
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/tonlibjson.dll
+          asset_name: tonlibjson.dll
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - libemulator
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/emulator.dll
+          asset_name: libemulator.dll
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Windows 2019 single artifact - tonlib-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/tonlib-cli.exe
+          asset_name: tonlib-cli.exe
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      # mac x86-64
+
+      - name: Upload Mac x86-64 artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos.zip
+          asset_name: ton-mac-x86-64.zip
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - fift
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/fift
+          asset_name: fift-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - func
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/func
+          asset_name: func-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/tolk
+          asset_name: tolk-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - lite-client
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/lite-client
+          asset_name: lite-client-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - proxy-liteserver
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/proxy-liteserver
+          asset_name: proxy-liteserver-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - rldp-http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/rldp-http-proxy
+          asset_name: rldp-http-proxy-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/http-proxy
+          asset_name: http-proxy-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - storage-daemon-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/storage-daemon-cli
+          asset_name: storage-daemon-cli-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - storage-daemon
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/storage-daemon
+          asset_name: storage-daemon-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - tonlibjson
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/libtonlibjson.dylib
+          asset_name: tonlibjson-mac-x86-64.dylib
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - libemulator
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/libemulator.dylib
+          asset_name: libemulator-mac-x86-64.dylib
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac x86-64 single artifact - tonlib-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/tonlib-cli
+          asset_name: tonlib-cli-mac-x86-64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+
+      # mac arm64
+
+      - name: Upload Mac arm64 artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos.zip
+          asset_name: ton-mac-arm64.zip
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - fift
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/fift
+          asset_name: fift-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - func
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/func
+          asset_name: func-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/tolk
+          asset_name: tolk-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - lite-client
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/lite-client
+          asset_name: lite-client-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - proxy-liteserver
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/proxy-liteserver
+          asset_name: proxy-liteserver-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - rldp-http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/rldp-http-proxy
+          asset_name: rldp-http-proxy-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/http-proxy
+          asset_name: http-proxy-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - storage-daemon-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/storage-daemon-cli
+          asset_name: storage-daemon-cli-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - storage-daemon
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/storage-daemon
+          asset_name: storage-daemon-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - tonlibjson
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/libtonlibjson.dylib
+          asset_name: tonlibjson-mac-arm64.dylib
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - libemulator
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/libemulator.dylib
+          asset_name: libemulator-mac-arm64.dylib
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Mac arm64 single artifact - tonlib-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/tonlib-cli
+          asset_name: tonlib-cli-mac-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      # linux x86-64
+
+      - name: Upload Linux x86-64 artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux.zip
+          asset_name: ton-linux-x86_64.zip
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload generic smartcont+lib artifact
+        run: |
+          mkdir smartcont_lib
+          cd smartcont_lib
+          cp -r ../artifacts/ton-x86_64-linux/{smartcont,lib} .          
+          zip -r smartcont_lib.zip .
+          gh release upload ${{ steps.tag.outputs.TAG }} smartcont_lib.zip
+
+      - name: Upload Linux x86-64 single artifact - fift
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/fift
+          asset_name: fift-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - func
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/func
+          asset_name: func-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/tolk
+          asset_name: tolk-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - lite-client
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/lite-client
+          asset_name: lite-client-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - proxy-liteserver
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/proxy-liteserver
+          asset_name: proxy-liteserver-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - rldp-http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/rldp-http-proxy
+          asset_name: rldp-http-proxy-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/http-proxy
+          asset_name: http-proxy-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - storage-daemon-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/storage-daemon-cli
+          asset_name: storage-daemon-cli-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - storage-daemon
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/storage-daemon
+          asset_name: storage-daemon-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - tonlibjson
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/libtonlibjson.so
+          asset_name: tonlibjson-linux-x86_64.so
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - libemulator
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/libemulator.so
+          asset_name: libemulator-linux-x86_64.so
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux x86-64 single artifact - tonlib-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/tonlib-cli
+          asset_name: tonlib-cli-linux-x86_64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+
+      # linux arm64
+
+      - name: Upload Linux arm64 artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux.zip
+          asset_name: ton-linux-arm64.zip
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - fift
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/fift
+          asset_name: fift-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - func
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/func
+          asset_name: func-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/tolk
+          asset_name: tolk-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - lite-client
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/lite-client
+          asset_name: lite-client-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - proxy-liteserver
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/proxy-liteserver
+          asset_name: proxy-liteserver-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - rldp-http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/rldp-http-proxy
+          asset_name: rldp-http-proxy-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - http-proxy
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/http-proxy
+          asset_name: http-proxy-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - storage-daemon-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/storage-daemon-cli
+          asset_name: storage-daemon-cli-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - storage-daemon
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/storage-daemon
+          asset_name: storage-daemon-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - tonlibjson
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/libtonlibjson.so
+          asset_name: tonlibjson-linux-arm64.so
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - libemulator
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/libemulator.so
+          asset_name: libemulator-linux-arm64.so
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Linux arm64 single artifact - tonlib-cli
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/tonlib-cli
+          asset_name: tonlib-cli-linux-arm64
+          tag: ${{ steps.tag.outputs.TAG }}
+
+
+      - name: Upload WASM artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-wasm.zip
+          asset_name: ton-wasm.zip
+          tag: ${{ steps.tag.outputs.TAG }}
+
+      - name: Upload Android Tonlib artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-android-tonlib.zip
+          asset_name: ton-android-tonlib.zip
+          tag: ${{ steps.tag.outputs.TAG }}

.github/workflows/create-tolk-release.yml

@@ -0,0 +1,154 @@
+name: Create tolk release
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'tolk release and tag name'
+        required: true
+
+permissions: write-all
+
+jobs:
+  create-release:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Download and unzip Linux arm64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-linux-arm64-appimage.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download and unzip Linux x86-64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-linux-x86-64-appimage.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download and unzip Mac x86-64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-macos-13-x86-64-portable.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download and unzip arm64 artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-macos-14-arm64-portable.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download and unzip Windows artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: ton-x86-64-windows.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: false
+
+      - name: Download WASM artifacts
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: build-ton-wasm-emscripten.yml
+          path: artifacts
+          workflow_conclusion: success
+          branch: master
+          skip_unpack: true
+
+      - name: Show all artifacts
+        run: |
+          tree artifacts
+      
+
+      # create release
+      - name: Get registration token
+        id: getRegToken
+        run: |
+          curl -X POST -H \"Accept: application/vnd.github+json\"  -H 'Authorization: token ${{ secrets.GITHUB_TOKEN }}' https://api.github.com/repos/ton-blockchain/ton/actions/runners/registration-token
+
+      - name: Create release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ inputs.tag }}
+          release_name: ${{ inputs.tag }}
+          draft: false
+          prerelease: false
+
+      # upload
+
+      # win
+
+      - name: Upload Windows 2019 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86-64-windows/tolk.exe
+          asset_name: tolk.exe
+          tag: ${{ inputs.tag }}
+
+      # mac x86-64
+
+      - name: Upload Mac x86-64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-macos/tolk
+          asset_name: tolk-mac-x86-64
+          tag: ${{ inputs.tag }}
+
+      # mac arm64
+
+      - name: Upload Mac arm64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-macos/tolk
+          asset_name: tolk-mac-arm64
+          tag: ${{ inputs.tag }}
+
+      # linux x86-64
+
+      - name: Upload Linux x86-64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-x86_64-linux/tolk
+          asset_name: tolk-linux-x86_64
+          tag: ${{ inputs.tag }}
+
+      # linux arm64
+
+      - name: Upload Linux arm64 single artifact - tolk
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-arm64-linux/tolk
+          asset_name: tolk-linux-arm64
+          tag: ${{ inputs.tag }}
+
+      - name: Upload WASM artifacts
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: artifacts/ton-wasm.zip
+          asset_name: ton-wasm.zip
+          tag: ${{ inputs.tag }}
+

.github/workflows/docker-ubuntu-branch-image.yml

@@ -0,0 +1,61 @@
+name: Docker Ubuntu 22.04 branch image
+
+on:
+  workflow_dispatch:
+  push:
+    branches-ignore:
+      - master
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.5.0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.10.0
+        with:
+          driver-opts: image=moby/buildkit:v0.11.0
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and export to Docker
+        uses: docker/build-push-action@v6
+        with:
+          load: true
+          context: ./
+          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:test
+
+      - name: Test
+        run: |
+          docker run --rm -e "TEST=1" ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:test
+
+      - name: Get tag as branch name
+        id: tag
+        run: |
+          echo "TAG=${GITHUB_REF##*/}" >> $GITHUB_OUTPUT
+
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v6
+        with:
+          platforms: linux/amd64,linux/arm64
+          push: true
+          context: ./
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.tag.outputs.TAG }}

.github/workflows/docker-ubuntu-image.yml

@@ -0,0 +1,68 @@
+name: Docker Ubuntu 22.04 image
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - 'master'
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.5.0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.10.0
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and export to Docker
+        uses: docker/build-push-action@v6
+        with:
+          load: true
+          context: ./
+          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:test
+
+      - name: Test
+        run: |
+          docker run --rm -e "TEST=1" ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:test
+
+      - name: Get next tag
+        id: tag
+        run: |
+          git fetch --all --tags
+          git tag -l
+          NEW_TAG=v$(date +'%Y.%m')
+          FOUND=$(git tag -l | grep $NEW_TAG | wc -l)
+          if [ $FOUND -eq 0 ]; then
+            echo "TAG=$NEW_TAG" >> $GITHUB_OUTPUT
+          else
+            echo "TAG=$NEW_TAG-$FOUND" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v6
+        with:
+          platforms: linux/amd64,linux/arm64
+          push: true
+          context: ./
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.tag.outputs.TAG }}

.github/workflows/ton-ccpcheck.yml

@@ -0,0 +1,26 @@
+name: TON Static Code Analysis
+
+on: [push,workflow_dispatch,workflow_call]
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+      with:      
+        submodules: 'recursive'
+
+    - name: Run Cppcheck
+      uses: Bedzior/run-cppcheck@master
+      with:
+        enabled checks: all
+        enable inconclusive: true
+        generate report: true
+
+    - name: Upload report
+      uses: actions/upload-artifact@master
+      with:
+        name: ton-ccpcheck-report
+        path: output

.github/workflows/ton-x86-64-windows.yml

@@ -0,0 +1,36 @@
+name: Windows TON build (portable, x86-64)
+
+on: [push,workflow_dispatch,workflow_call]
+
+defaults:
+  run:
+    shell: cmd
+
+jobs:
+  build:
+
+    runs-on: windows-2019
+
+    steps:
+      - name: Get Current OS version
+        run: |
+          systeminfo | findstr /B /C:"OS Name" /C:"OS Version"
+
+      - name: Check out current repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Build TON
+        run: |
+          git submodule sync --recursive
+          git submodule update
+          copy assembly\native\build-windows-github-2019.bat .
+          copy assembly\native\build-windows-2019.bat .
+          build-windows-github-2019.bat Enterprise
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@master
+        with:
+          name: ton-x86-64-windows
+          path: artifacts

.gitignore

@@ -11,3 +11,16 @@ crypto/smartcont/auto/
 test/regression-tests.cache/
 *.swp
 **/*build*/
+.idea
+.vscode
+.DS_Store
+dev/
+zlib/
+libsodium/
+libmicrohttpd-0.9.77-w32-bin/
+readline-5.0-1-lib/
+openssl-3.1.4/
+libsodium-1.0.18-stable-msvc.zip
+libmicrohttpd-0.9.77-w32-bin.zip
+openssl-3.1.4.zip
+readline-5.0-1-lib.zip

.gitmodules

@@ -10,3 +10,10 @@
 [submodule "third-party/libraptorq"]
 	path = third-party/libraptorq
 	url = https://github.com/ton-blockchain/libRaptorQ
+[submodule "third-party/blst"]
+	path = third-party/blst
+	url = https://github.com/supranational/blst.git
+[submodule "third-party/secp256k1"]
+	path = third-party/secp256k1
+	url = https://github.com/bitcoin-core/secp256k1
+	branch = v0.3.2

CMake/BuildBLST.cmake

@@ -0,0 +1,30 @@
+set(BLST_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third-party/blst)
+set(BLST_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/third-party/blst)
+set(BLST_INCLUDE_DIR ${BLST_SOURCE_DIR}/bindings)
+
+if (NOT BLST_LIB)
+    if (WIN32)
+      set(BLST_LIB ${BLST_BINARY_DIR}/blst.lib)
+      set(BLST_BUILD_COMMAND ${BLST_SOURCE_DIR}/build.bat)
+    else()
+      set(BLST_LIB ${BLST_BINARY_DIR}/libblst.a)
+      if (PORTABLE)
+        set(BLST_BUILD_COMMAND ${BLST_SOURCE_DIR}/build.sh -D__BLST_PORTABLE__)
+      else()
+        set(BLST_BUILD_COMMAND ${BLST_SOURCE_DIR}/build.sh)
+      endif()
+    endif()
+
+    file(MAKE_DIRECTORY ${BLST_BINARY_DIR})
+    add_custom_command(
+      WORKING_DIRECTORY ${BLST_BINARY_DIR}
+      COMMAND ${BLST_BUILD_COMMAND}
+      COMMENT "Build blst"
+      DEPENDS ${BLST_SOURCE_DIR}
+      OUTPUT ${BLST_LIB}
+    )
+else()
+   message(STATUS "Use BLST: ${BLST_LIB}")
+endif()
+
+add_custom_target(blst DEPENDS ${BLST_LIB})

CMake/BuildSECP256K1.cmake

@@ -0,0 +1,55 @@
+if (NOT SECP256K1_LIBRARY)
+
+    set(SECP256K1_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third-party/secp256k1)
+    set(SECP256K1_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/third-party/secp256k1)
+    set(SECP256K1_INCLUDE_DIR ${SECP256K1_BINARY_DIR}/include)
+
+    file(MAKE_DIRECTORY ${SECP256K1_BINARY_DIR})
+    file(MAKE_DIRECTORY "${SECP256K1_BINARY_DIR}/include")
+
+    if (MSVC)
+      set(SECP256K1_BINARY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third-party/secp256k1)
+      set(SECP256K1_LIBRARY ${SECP256K1_SOURCE_DIR}/build/src/Release/libsecp256k1.lib)
+      set(SECP256K1_INCLUDE_DIR ${SECP256K1_BINARY_DIR}/include)
+      add_custom_command(
+        WORKING_DIRECTORY ${SECP256K1_SOURCE_DIR}
+        COMMAND cmake -E env CFLAGS="/WX" cmake -A x64 -B build -DSECP256K1_ENABLE_MODULE_RECOVERY=ON -DSECP256K1_ENABLE_MODULE_EXTRAKEYS=ON -DSECP256K1_BUILD_EXAMPLES=OFF -DBUILD_SHARED_LIBS=OFF
+        COMMAND cmake --build build --config Release
+        COMMENT "Build Secp256k1"
+        DEPENDS ${SECP256K1_SOURCE_DIR}
+        OUTPUT ${SECP256K1_LIBRARY}
+      )
+    elseif (EMSCRIPTEN)
+      set(SECP256K1_BINARY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third-party/secp256k1)
+      set(SECP256K1_LIBRARY ${SECP256K1_BINARY_DIR}/.libs/libsecp256k1.a)
+      set(SECP256K1_INCLUDE_DIR ${SECP256K1_SOURCE_DIR}/include)
+      add_custom_command(
+          WORKING_DIRECTORY ${SECP256K1_SOURCE_DIR}
+          COMMAND ./autogen.sh
+          COMMAND emconfigure ./configure --enable-module-recovery --enable-module-extrakeys --disable-tests --disable-benchmark
+          COMMAND emmake make clean
+          COMMAND emmake make
+          COMMENT "Build Secp256k1 with emscripten"
+          DEPENDS ${SECP256K1_SOURCE_DIR}
+          OUTPUT ${SECP256K1_LIBRARY}
+      )
+    else()
+      if (NOT NIX)
+        set(SECP256K1_LIBRARY ${SECP256K1_BINARY_DIR}/lib/libsecp256k1.a)
+        add_custom_command(
+            WORKING_DIRECTORY ${SECP256K1_SOURCE_DIR}
+            COMMAND ./autogen.sh
+            COMMAND ./configure -q --disable-option-checking --enable-module-recovery --enable-module-extrakeys --prefix ${SECP256K1_BINARY_DIR} --with-pic --disable-shared --enable-static --disable-tests --disable-benchmark
+            COMMAND make -j16
+            COMMAND make install
+            COMMENT "Build secp256k1"
+            DEPENDS ${SECP256K1_SOURCE_DIR}
+            OUTPUT ${SECP256K1_LIBRARY}
+        )
+      endif()
+    endif()
+else()
+   message(STATUS "Use Secp256k1: ${SECP256K1_LIBRARY}")
+endif()
+
+add_custom_target(secp256k1 DEPENDS ${SECP256K1_LIBRARY})

CMake/FindMHD.cmake

@@ -2,37 +2,27 @@
 # Once done this will define
 #
 #  MHD_FOUND - system has MHD
-#  MHD_INCLUDE_DIRS - the MHD include directory
+#  MHD_INCLUDE_DIR - the MHD include directory
 #  MHD_LIBRARY - Link these to use MHD
 
-find_path(
-    MHD_INCLUDE_DIR
-    NAMES microhttpd.h
-    DOC "microhttpd include dir"
-)
-
-find_library(
-    MHD_LIBRARY
-    NAMES microhttpd microhttpd-10 libmicrohttpd libmicrohttpd-dll
-    DOC "microhttpd library"
-)
-
-set(MHD_INCLUDE_DIRS ${MHD_INCLUDE_DIR})
-set(MHD_LIBRARIES ${MHD_LIBRARY})
-
-# debug library on windows
-# same naming convention as in qt (appending debug library with d)
-# boost is using the same "hack" as us with "optimized" and "debug"
-# official MHD project actually uses _d suffix
-if (MSVC)
-    find_library(
-        MHD_LIBRARY_DEBUG
-        NAMES microhttpd_d microhttpd-10_d libmicrohttpd_d libmicrohttpd-dll_d
-        DOC "mhd debug library"
+if (NOT MHD_LIBRARY)
+    find_path(
+        MHD_INCLUDE_DIR
+        NAMES microhttpd.h
+        DOC "microhttpd include dir"
     )
-    set(MHD_LIBRARIES optimized ${MHD_LIBRARIES} debug ${MHD_LIBRARY_DEBUG})
+
+    find_library(
+        MHD_LIBRARY
+        NAMES microhttpd microhttpd-10 libmicrohttpd libmicrohttpd-dll
+        DOC "microhttpd library"
+    )
+endif()
+
+if (MHD_LIBRARY)
+  message(STATUS "Found MHD: ${MHD_LIBRARY}")
 endif()
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(mhd DEFAULT_MSG MHD_INCLUDE_DIR MHD_LIBRARY)
+find_package_handle_standard_args(MHD DEFAULT_MSG MHD_INCLUDE_DIR MHD_LIBRARY)
 mark_as_advanced(MHD_INCLUDE_DIR MHD_LIBRARY)

CMake/FindSecp256k1.cmake

@@ -0,0 +1,27 @@
+# - Try to find Secp256k1
+# Once done this will define
+#
+#  SECP256K1_INCLUDE_DIR - the Secp256k1 include directory
+#  SECP256K1_LIBRARY - Link these to use Secp256k1
+
+if (NOT SECP256K1_LIBRARY)
+    find_path(
+        SECP256K1_INCLUDE_DIR
+        NAMES secp256k1_recovery.h
+        DOC "secp256k1_recovery.h include dir"
+    )
+
+    find_library(
+        SECP256K1_LIBRARY
+        NAMES secp256k1 libsecp256k1
+        DOC "secp256k1 library"
+    )
+endif()
+
+if (SECP256K1_LIBRARY)
+  message(STATUS "Found Secp256k1: ${SECP256K1_LIBRARY}")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Secp256k1 DEFAULT_MSG SECP256K1_INCLUDE_DIR SECP256K1_LIBRARY)
+mark_as_advanced(SECP256K1_INCLUDE_DIR SECP256K1_LIBRARY)

CMake/FindSodium.cmake

@@ -0,0 +1,306 @@
+# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
+#
+# To the extent possible under law, the author(s) have dedicated all
+# copyright and related and neighboring rights to this software to the
+# public domain worldwide. This software is distributed without any warranty.
+#
+# You should have received a copy of the CC0 Public Domain Dedication
+# along with this software. If not, see
+#
+#     http://creativecommons.org/publicdomain/zero/1.0/
+#
+########################################################################
+# Tries to find the local libsodium installation.
+#
+# On Windows the SODIUM_DIR environment variable is used as a default
+# hint which can be overridden by setting the corresponding cmake variable.
+#
+# Once done the following variables will be defined:
+#
+#   SODIUM_FOUND
+#   SODIUM_INCLUDE_DIR
+#   SODIUM_LIBRARY_DEBUG
+#   SODIUM_LIBRARY_RELEASE
+#
+#
+# Furthermore an imported "sodium" target is created.
+#
+
+
+if (CMAKE_C_COMPILER_ID STREQUAL "GNU"
+  OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
+  set(_GCC_COMPATIBLE 1)
+endif()
+
+# static library option
+if (NOT DEFINED SODIUM_USE_STATIC_LIBS)
+  option(SODIUM_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
+endif()
+if(NOT (SODIUM_USE_STATIC_LIBS EQUAL SODIUM_USE_STATIC_LIBS_LAST))
+  if (NOT SODIUM_LIBRARY_RELEASE)
+    unset(sodium_LIBRARY CACHE)
+    unset(SODIUM_LIBRARY_DEBUG CACHE)
+    unset(SODIUM_LIBRARY_RELEASE CACHE)
+    unset(sodium_DLL_DEBUG CACHE)
+    unset(sodium_DLL_RELEASE CACHE)
+    set(SODIUM_USE_STATIC_LIBS_LAST ${SODIUM_USE_STATIC_LIBS} CACHE INTERNAL "internal change tracking variable")
+  endif()
+endif()
+
+
+########################################################################
+# UNIX
+if (UNIX)
+  # import pkg-config
+  find_package(PkgConfig QUIET)
+  if (PKG_CONFIG_FOUND)
+    pkg_check_modules(sodium_PKG QUIET libsodium)
+  endif()
+
+  if(SODIUM_USE_STATIC_LIBS)
+    foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
+      if (NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending with .a
+        list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
+      endif()
+    endforeach()
+    list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
+
+    # if pkgconfig for libsodium doesn't provide
+    # static lib info, then override PKG_STATIC here..
+    if (NOT sodium_PKG_STATIC_FOUND)
+      set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
+    endif()
+
+    set(XPREFIX sodium_PKG_STATIC)
+  else()
+    if (NOT sodium_PKG_FOUND)
+      set(sodium_PKG_LIBRARIES sodium)
+    endif()
+
+    set(XPREFIX sodium_PKG)
+  endif()
+
+  find_path(SODIUM_INCLUDE_DIR sodium.h
+    HINTS ${${XPREFIX}_INCLUDE_DIRS}
+    )
+  find_library(SODIUM_LIBRARY_DEBUG NAMES ${${XPREFIX}_LIBRARIES}
+    HINTS ${${XPREFIX}_LIBRARY_DIRS}
+    )
+  find_library(SODIUM_LIBRARY_RELEASE NAMES ${${XPREFIX}_LIBRARIES}
+    HINTS ${${XPREFIX}_LIBRARY_DIRS}
+    )
+
+  ########################################################################
+  # Windows
+elseif (WIN32)
+  set(SODIUM_DIR "$ENV{SODIUM_DIR}" CACHE FILEPATH "sodium install directory")
+  mark_as_advanced(SODIUM_DIR)
+
+  find_path(SODIUM_INCLUDE_DIR
+    NAMES sodium.h
+    HINTS ${SODIUM_DIR}
+    PATH_SUFFIXES include
+    )
+
+  if (MSVC)
+    # detect target architecture
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp" [=[
+            #if defined _M_IX86
+            #error ARCH_VALUE x86_32
+            #elif defined _M_X64
+            #error ARCH_VALUE x86_64
+            #endif
+            #error ARCH_VALUE unknown
+        ]=])
+    try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp"
+      OUTPUT_VARIABLE _COMPILATION_LOG
+      )
+    string(REGEX REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*" "\\1" _TARGET_ARCH "${_COMPILATION_LOG}")
+
+    # construct library path
+    if (_TARGET_ARCH STREQUAL "x86_32")
+      string(APPEND _PLATFORM_PATH "Win32")
+    elseif(_TARGET_ARCH STREQUAL "x86_64")
+      string(APPEND _PLATFORM_PATH "x64")
+    else()
+      message(FATAL_ERROR "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake.")
+    endif()
+    string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
+
+    message(STATUS "MSVC_VERSION ${MSVC_VERSION}")
+    if (MSVC_VERSION LESS 1900)
+      math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
+    else()
+      if (MSVC_VERSION EQUAL 1941)
+        math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 51")
+      else()
+        math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
+      endif()
+
+    endif()
+    string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
+
+    if (SODIUM_USE_STATIC_LIBS)
+      string(APPEND _PLATFORM_PATH "/static")
+    else()
+      string(APPEND _PLATFORM_PATH "/dynamic")
+    endif()
+
+    string(REPLACE "$$CONFIG$$" "Debug" _DEBUG_PATH_SUFFIX "${_PLATFORM_PATH}")
+    string(REPLACE "$$CONFIG$$" "Release" _RELEASE_PATH_SUFFIX "${_PLATFORM_PATH}")
+
+    find_library(SODIUM_LIBRARY_DEBUG libsodium.lib
+      HINTS ${SODIUM_DIR}
+      PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+      )
+    find_library(SODIUM_LIBRARY_RELEASE libsodium.lib
+      HINTS ${SODIUM_DIR}
+      PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
+      )
+    if (NOT SODIUM_USE_STATIC_LIBS)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
+      set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
+      find_library(sodium_DLL_DEBUG libsodium
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+        )
+      find_library(sodium_DLL_RELEASE libsodium
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
+        )
+      set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
+    endif()
+
+  elseif(_GCC_COMPATIBLE)
+    if (SODIUM_USE_STATIC_LIBS)
+      find_library(SODIUM_LIBRARY_DEBUG libsodium.a
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES lib
+        )
+      find_library(SODIUM_LIBRARY_RELEASE libsodium.a
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES lib
+        )
+    else()
+      find_library(SODIUM_LIBRARY_DEBUG libsodium.dll.a
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES lib
+        )
+      find_library(SODIUM_LIBRARY_RELEASE libsodium.dll.a
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES lib
+        )
+
+      file(GLOB _DLL
+        LIST_DIRECTORIES false
+        RELATIVE "${SODIUM_DIR}/bin"
+        "${SODIUM_DIR}/bin/libsodium*.dll"
+        )
+      find_library(sodium_DLL_DEBUG ${_DLL} libsodium
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES bin
+        )
+      find_library(sodium_DLL_RELEASE ${_DLL} libsodium
+        HINTS ${SODIUM_DIR}
+        PATH_SUFFIXES bin
+        )
+    endif()
+  else()
+    message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+  endif()
+
+
+  ########################################################################
+  # unsupported
+else()
+  message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+endif()
+
+
+########################################################################
+# common stuff
+
+# extract sodium version
+if (SODIUM_INCLUDE_DIR)
+  set(_VERSION_HEADER "${_INCLUDE_DIR}/sodium/version.h")
+  if (EXISTS _VERSION_HEADER)
+    file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
+    string(REGEX REPLACE ".*#[ \t]*define[ \t]*SODIUM_VERSION_STRING[ \t]*\"([^\n]*)\".*" "\\1"
+      sodium_VERSION "${_VERSION_HEADER_CONTENT}")
+    set(sodium_VERSION "${sodium_VERSION}" PARENT_SCOPE)
+  endif()
+endif()
+
+# communicate results
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+  Sodium # The name must be either uppercase or match the filename case.
+  REQUIRED_VARS
+  SODIUM_LIBRARY_RELEASE
+  SODIUM_LIBRARY_DEBUG
+  SODIUM_INCLUDE_DIR
+  VERSION_VAR
+  sodium_VERSION
+)
+
+if(SODIUM_FOUND)
+  set(SODIUM_LIBRARIES
+    optimized ${SODIUM_LIBRARY_RELEASE} debug ${SODIUM_LIBRARY_DEBUG})
+endif()
+
+# mark file paths as advanced
+mark_as_advanced(SODIUM_INCLUDE_DIR)
+mark_as_advanced(SODIUM_LIBRARY_DEBUG)
+mark_as_advanced(SODIUM_LIBRARY_RELEASE)
+if (WIN32)
+  mark_as_advanced(sodium_DLL_DEBUG)
+  mark_as_advanced(sodium_DLL_RELEASE)
+endif()
+
+# create imported target
+if(SODIUM_USE_STATIC_LIBS)
+  set(_LIB_TYPE STATIC)
+else()
+  set(_LIB_TYPE SHARED)
+endif()
+
+if(NOT TARGET sodium)
+  add_library(sodium ${_LIB_TYPE} IMPORTED)
+endif()
+
+set_target_properties(sodium PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${SODIUM_INCLUDE_DIR}"
+  IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+  )
+
+if (SODIUM_USE_STATIC_LIBS)
+  set_target_properties(sodium PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "SODIUM_STATIC"
+    IMPORTED_LOCATION "${SODIUM_LIBRARY_RELEASE}"
+    IMPORTED_LOCATION_DEBUG "${SODIUM_LIBRARY_DEBUG}"
+    )
+else()
+  if (UNIX)
+    set_target_properties(sodium PROPERTIES
+      IMPORTED_LOCATION "${SODIUM_LIBRARY_RELEASE}"
+      IMPORTED_LOCATION_DEBUG "${SODIUM_LIBRARY_DEBUG}"
+      )
+  elseif (WIN32)
+    set_target_properties(sodium PROPERTIES
+      IMPORTED_IMPLIB "${SODIUM_LIBRARY_RELEASE}"
+      IMPORTED_IMPLIB_DEBUG "${SODIUM_LIBRARY_DEBUG}"
+      )
+    if (NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
+      set_target_properties(sodium PROPERTIES
+        IMPORTED_LOCATION_DEBUG "${sodium_DLL_DEBUG}"
+        )
+    endif()
+    if (NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
+      set_target_properties(sodium PROPERTIES
+        IMPORTED_LOCATION_RELWITHDEBINFO "${sodium_DLL_RELEASE}"
+        IMPORTED_LOCATION_MINSIZEREL "${sodium_DLL_RELEASE}"
+        IMPORTED_LOCATION_RELEASE "${sodium_DLL_RELEASE}"
+        )
+    endif()
+  endif()
+endif()

CMakeLists.txt

@@ -1,9 +1,19 @@
-cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
 
 project(TON VERSION 0.5 LANGUAGES C CXX)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 #set(OPENSSL_USE_STATIC_LIBS TRUE)
 
+# Define the two required variables before including the source code for watching a git repository.
+set(PRE_CONFIGURE_FILE "git.cc.in")
+set(POST_CONFIGURE_FILE "${CMAKE_CURRENT_BINARY_DIR}/git.cc")
+include(git_watcher.cmake)
+
+# Create a library out of the compiled post-configure file.
+add_library(git STATIC ${POST_CONFIGURE_FILE})
+target_include_directories(git PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+add_dependencies(git check_git)
+
 # Prevent in-source build
 get_filename_component(TON_REAL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" REALPATH)
 get_filename_component(TON_REAL_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" REALPATH)
@@ -69,8 +79,17 @@ else()
   set(HAVE_SSE42 FALSE)
 endif()
 
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_EXTENSIONS FALSE)
+
 #BEGIN internal
+option(BUILD_SHARED_LIBS "Use \"ON\" to build shared libraries instead of static where it's not specified (not recommended)" OFF)
+option(USE_EMSCRIPTEN "Use \"ON\" for config building wasm." OFF)
 option(TON_ONLY_TONLIB "Use \"ON\" to build only tonlib." OFF)
+if (USE_EMSCRIPTEN)
+  set(TON_ONLY_TONLIB true)
+endif()
 if (TON_ONLY_TONLIB)
   set(NOT_TON_ONLY_TONLIB false)
 else()
@@ -87,8 +106,18 @@ option(TON_USE_TSAN "Use \"ON\" to enable ThreadSanitizer." OFF)
 option(TON_USE_UBSAN "Use \"ON\" to enable UndefinedBehaviorSanitizer." OFF)
 set(TON_ARCH "native" CACHE STRING "Architecture, will be passed to -march=")
 
+#BEGIN M1 support
+EXECUTE_PROCESS( COMMAND uname -m COMMAND tr -d '\n' OUTPUT_VARIABLE ARCHITECTURE )
+
+if ((ARCHITECTURE MATCHES "arm64") AND (CMAKE_SYSTEM_NAME STREQUAL "Darwin") AND
+    (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 13.0)) # only clang 13+ supports cpu=apple-m1
+    set(TON_ARCH "apple-m1")
+endif()
+#END M1 support
+
 if (TON_USE_ABSEIL)
   message("Add abseil-cpp")
+  set(ABSL_PROPAGATE_CXX_STD TRUE)
   add_subdirectory(third-party/abseil-cpp EXCLUDE_FROM_ALL)
   set(ABSL_FOUND 1)
 endif()
@@ -108,11 +137,20 @@ set(CRC32C_BUILD_BENCHMARKS OFF CACHE BOOL "Build CRC32C's benchmarks")
 set(CRC32C_USE_GLOG OFF CACHE BOOL "Build CRC32C's tests with Google Logging")
 set(CRC32C_INSTALL OFF CACHE BOOL "Install CRC32C's header and library")
 message("Add crc32c")
-add_subdirectory(third-party/crc32c EXCLUDE_FROM_ALL)
+if (NOT MSVC)
+  set(OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+  # fix aarch64 build @ crc32c/src/crc32c_arm64_linux_check.h
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=address")
+  add_subdirectory(third-party/crc32c EXCLUDE_FROM_ALL)
+  set(CMAKE_CXX_FLAGS ${OLD_CMAKE_CXX_FLAGS})
+  unset(OLD_CMAKE_CXX_FLAGS)
+else()
+  add_subdirectory(third-party/crc32c EXCLUDE_FROM_ALL)
+endif()
 set(CRC32C_FOUND 1)
 
 if (TON_USE_ROCKSDB)
-  if (ANDROID) 
+  if (ANDROID)
     set(PORTABLE ON CACHE BOOL "portable")
   endif()
   set(WITH_GFLAGS OFF CACHE BOOL "build with GFlags")
@@ -145,6 +183,9 @@ endif()
 message("Add ton")
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake" ${CMAKE_MODULE_PATH})
 
+include(BuildBLST)
+include(BuildSECP256K1)
+
 # Configure CCache if available
 find_program(CCACHE_FOUND ccache)
 #set(CCACHE_FOUND 0)
@@ -168,42 +209,41 @@ endif()
 
 include(CheckCXXCompilerFlag)
 
-if (GCC OR CLANG OR INTEL)
-  if (WIN32 AND INTEL)
-    set(STD14_FLAG /Qstd=c++14)
-  else()
-    set(STD14_FLAG -std=c++14)
-  endif()
-  check_cxx_compiler_flag(${STD14_FLAG} HAVE_STD14)
-  if (NOT HAVE_STD14)
-    string(REPLACE "c++14" "c++1y" STD14_FLAG "${STD14_FLAG}")
-    check_cxx_compiler_flag(${STD14_FLAG} HAVE_STD1Y)
-    set(HAVE_STD14 ${HAVE_STD1Y})
-  endif()
-elseif (MSVC)
-  set(HAVE_STD14 MSVC_VERSION>=1900)
-endif()
-
-if (NOT HAVE_STD14)
-  message(FATAL_ERROR "No C++14 support in the compiler. Please upgrade the compiler.")
-endif()
-
 set(CMAKE_THREAD_PREFER_PTHREAD ON)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
-find_package(ZLIB REQUIRED)
+find_package(PkgConfig REQUIRED)
+
+if (NOT ZLIB_FOUND)
+  find_package(ZLIB REQUIRED)
+else()
+  message(STATUS "Using zlib ${ZLIB_LIBRARIES}")
+endif()
+
 
 if (TON_ARCH AND NOT MSVC)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${TON_ARCH}")
+  CHECK_CXX_COMPILER_FLAG( "-march=${TON_ARCH}" COMPILER_OPT_ARCH_SUPPORTED )
+  if (TON_ARCH STREQUAL "apple-m1")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=${TON_ARCH}")	
+  elseif(COMPILER_OPT_ARCH_SUPPORTED)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${TON_ARCH}")
+  elseif(NOT TON_ARCH STREQUAL "native")
+    message(FATAL_ERROR "Compiler doesn't support arch ${TON_ARCH}")
+  endif()
 endif()
 if (THREADS_HAVE_PTHREAD_ARG)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 endif()
 
 if (TON_USE_JEMALLOC)
-  find_package(JeMalloc REQUIRED)
+  find_package(jemalloc REQUIRED)
 endif()
 
+if (NIX)
+  find_package(Secp256k1 REQUIRED)
+endif()
+
+
 set(MEMPROF "" CACHE STRING "Use one of \"ON\", \"FAST\" or \"SAFE\" to enable memory profiling. \
 Works under macOS and Linux when compiled using glibc. \
 In FAST mode stack is unwinded only using frame pointers, which may fail. \
@@ -228,21 +268,26 @@ if (MSVC)
   add_definitions(-D_SCL_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /W4 /wd4100 /wd4127 /wd4324 /wd4456 /wd4457 /wd4458 /wd4505 /wd4702")
 elseif (CLANG OR GCC)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${STD14_FLAG} -fno-omit-frame-pointer")
+  if (GCC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstrong-eval-order=some")
+  endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer")
   if (APPLE)
     #use "-Wl,-exported_symbols_list,${CMAKE_CURRENT_SOURCE_DIR}/export_list" for exported symbols
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fvisibility=hidden -Wl,-dead_strip,-x,-S")
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -fvisibility=hidden -Wl,-dead_strip,-x,-S")
   else()
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections")
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,--exclude-libs,ALL")
+    if (NOT USE_EMSCRIPTEN)
+      set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,--exclude-libs,ALL")
+    endif()
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
     if (NOT TON_USE_ASAN AND NOT TON_USE_TSAN AND NOT MEMPROF)
-      set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--exclude-libs,ALL")
+      if (NOT USE_EMSCRIPTEN)
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--exclude-libs,ALL")
+      endif()
     endif()
   endif()
-elseif (INTEL)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${STD14_FLAG}")
 endif()
 
 if (WIN32)
@@ -274,8 +319,9 @@ if (MSVC)
 endif()
 if (NOT MSVC)
   add_cxx_compiler_flag("-Wall")
+  add_cxx_compiler_flag("-Wextra")
 endif()
-add_cxx_compiler_flag("-Wextra")
+
 add_cxx_compiler_flag("-Wimplicit-fallthrough=2")
 add_cxx_compiler_flag("-Wpointer-arith")
 add_cxx_compiler_flag("-Wcast-qual")
@@ -294,6 +340,10 @@ add_cxx_compiler_flag("-Wno-sign-conversion")
 add_cxx_compiler_flag("-Qunused-arguments")
 add_cxx_compiler_flag("-Wno-unused-private-field")
 add_cxx_compiler_flag("-Wno-redundant-move")
+
+#add_cxx_compiler_flag("-Wno-unused-function")
+#add_cxx_compiler_flag("-Wno-unused-variable")
+#add_cxx_compiler_flag("-Wno-shorten-64-to-32")
 #add_cxx_compiler_flag("-Werror")
 
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem /usr/include/c++/v1")
@@ -338,6 +388,9 @@ if (LATEX_FOUND)
   add_latex_document(doc/fiftbase.tex TARGET_NAME fift_basic_description)
   add_latex_document(doc/catchain.tex TARGET_NAME catchain_consensus_description)
 endif()
+if (NOT LATEX_FOUND)
+  message(STATUS "Could NOT find LATEX (this is NOT an error)")
+endif()
 #END internal
 
 function(target_link_libraries_system target)
@@ -366,6 +419,8 @@ add_subdirectory(tl-utils)
 add_subdirectory(adnl)
 add_subdirectory(crypto)
 add_subdirectory(lite-client)
+add_subdirectory(emulator)
+add_subdirectory(tolk)
 
 #BEGIN tonlib
 add_subdirectory(tonlib)
@@ -413,6 +468,13 @@ target_link_libraries(test-vm PRIVATE ton_crypto fift-lib)
 add_executable(test-smartcont test/test-td-main.cpp ${SMARTCONT_TEST_SOURCE})
 target_link_libraries(test-smartcont PRIVATE smc-envelope fift-lib ton_db)
 
+add_executable(test-bigint ${BIGINT_TEST_SOURCE})
+target_link_libraries(test-bigint PRIVATE ton_crypto)
+
+if (WINGETOPT_FOUND)
+  target_link_libraries_system(test-bigint wingetopt)
+endif()
+
 add_executable(test-cells test/test-td-main.cpp ${CELLS_TEST_SOURCE})
 target_link_libraries(test-cells PRIVATE ton_crypto)
 
@@ -434,10 +496,10 @@ target_link_libraries(test-net PRIVATE tdnet tdutils ${CMAKE_THREAD_LIBS_INIT})
 
 #BEGIN tonlib
 add_executable(test-tonlib ${TONLIB_ONLINE_TEST_SOURCE})
-target_link_libraries(test-tonlib tdutils tdactor adnllite tl_api ton_crypto ton_block tl_tonlib_api tonlib)
+target_link_libraries(test-tonlib tdactor adnllite tl_api ton_crypto tl_tonlib_api tonlib)
 
 add_executable(test-tonlib-offline test/test-td-main.cpp ${TONLIB_OFFLINE_TEST_SOURCE})
-target_link_libraries(test-tonlib-offline tdutils tdactor adnllite tl_api ton_crypto ton_block fift-lib tl_tonlib_api tonlib)
+target_link_libraries(test-tonlib-offline tdactor adnllite tl_api ton_crypto fift-lib tl_tonlib_api tonlib)
 
 if (NOT CMAKE_CROSSCOMPILING)
   add_dependencies(test-tonlib-offline gen_fif)
@@ -479,30 +541,21 @@ target_link_libraries(test-rldp2 adnl adnltest dht rldp2 tl_api)
 add_executable(test-validator-session-state test/test-validator-session-state.cpp)
 target_link_libraries(test-validator-session-state adnl dht rldp validatorsession tl_api)
 
-#add_executable(test-node test/test-node.cpp)
-#target_link_libraries(test-node overlay tdutils tdactor adnl tl_api dht
-#  catchain validatorsession)
-
+add_executable(test-overlay test/test-overlay.cpp)
+target_link_libraries(test-overlay overlay tdutils tdactor adnl adnltest tl_api dht )
 add_executable(test-catchain test/test-catchain.cpp)
 target_link_libraries(test-catchain overlay tdutils tdactor adnl adnltest rldp tl_api dht
   catchain )
-#add_executable(test-validator-session test/test-validator-session.cpp)
-#target_link_libraries(test-validator-session overlay tdutils tdactor adnl tl_api dht
-#  catchain validatorsession)
 add_executable(test-ton-collator test/test-ton-collator.cpp)
 target_link_libraries(test-ton-collator overlay tdutils tdactor adnl tl_api dht
   catchain validatorsession validator-disk ton_validator validator-disk )
-#add_executable(test-validator test/test-validator.cpp)
-#target_link_libraries(test-validator overlay tdutils tdactor adnl tl_api dht
-#    rldp catchain validatorsession ton-node validator ton_validator validator memprof ${JEMALLOC_LIBRARIES})
-#add_executable(test-ext-server test/test-ext-server.cpp)
-#target_link_libraries(test-ext-server tdutils tdactor adnl tl_api dht )
-#add_executable(test-ext-client test/test-ext-client.cpp)
-#target_link_libraries(test-ext-client tdutils tdactor adnl tl_api tl-lite-utils)
 
 add_executable(test-http test/test-http.cpp)
 target_link_libraries(test-http PRIVATE tonhttp)
 
+add_executable(test-emulator test/test-td-main.cpp emulator/test/emulator-tests.cpp)
+target_link_libraries(test-emulator PRIVATE emulator)
+
 get_directory_property(HAS_PARENT PARENT_DIRECTORY)
 if (HAS_PARENT)
   set(ALL_TEST_SOURCE
@@ -513,6 +566,7 @@ if (HAS_PARENT)
           ${FEC_TEST_SOURCE}
           ${ED25519_TEST_SOURCE}
           ${TONDB_TEST_SOURCE}
+          ${BIGNUM_TEST_SOURCE}
           ${CELLS_TEST_SOURCE} # ${TONVM_TEST_SOURCE} ${FIFT_TEST_SOURCE} ${TONLIB_ONLINE_TEST_SOURCE}
           PARENT_SCOPE)
 endif()
@@ -526,25 +580,91 @@ set(TEST_OPTIONS "--regression ${CMAKE_CURRENT_SOURCE_DIR}/test/regression-tests
 separate_arguments(TEST_OPTIONS)
 add_test(test-ed25519-crypto crypto/test-ed25519-crypto)
 add_test(test-ed25519 test-ed25519)
+add_test(test-bigint test-bigint)
 add_test(test-vm test-vm ${TEST_OPTIONS})
 add_test(test-fift test-fift ${TEST_OPTIONS})
 add_test(test-cells test-cells ${TEST_OPTIONS})
 add_test(test-smartcont test-smartcont)
 add_test(test-net test-net)
 add_test(test-actors test-tdactor)
+add_test(test-emulator test-emulator)
 
 #BEGIN tonlib
 add_test(test-tdutils test-tdutils)
 add_test(test-tonlib-offline test-tonlib-offline)
 #END tonlib
 
+# FunC tests
+if (NOT NIX)
+    if (MSVC)
+      set(PYTHON_VER "python")
+    else()
+      set(PYTHON_VER "python3")
+    endif()
+    add_test(
+      NAME test-func
+      COMMAND ${PYTHON_VER} run_tests.py tests/
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/crypto/func/auto-tests)
+    if (WIN32)
+        set_property(TEST test-func PROPERTY ENVIRONMENT
+          "FUNC_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/func.exe"
+          "FIFT_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/fift.exe"
+          "FIFTPATH=${CMAKE_CURRENT_SOURCE_DIR}/crypto/fift/lib/")
+    else()
+        set_property(TEST test-func PROPERTY ENVIRONMENT
+          "FUNC_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/func"
+          "FIFT_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/fift"
+          "FIFTPATH=${CMAKE_CURRENT_SOURCE_DIR}/crypto/fift/lib/")
+    endif()
+
+    add_test(
+      NAME test-func-legacy
+      COMMAND ${PYTHON_VER} legacy_tester.py
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/crypto/func/auto-tests)
+    if (WIN32)
+        set_property(TEST test-func-legacy PROPERTY ENVIRONMENT
+          "FUNC_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/func.exe"
+          "FIFT_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/fift.exe"
+          "FIFTPATH=${CMAKE_CURRENT_SOURCE_DIR}/crypto/fift/lib/")
+    else()
+        set_property(TEST test-func-legacy PROPERTY ENVIRONMENT
+          "FUNC_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/func"
+          "FIFT_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/fift"
+          "FIFTPATH=${CMAKE_CURRENT_SOURCE_DIR}/crypto/fift/lib/")
+    endif()
+endif()
+
+# Tolk tests
+if (NOT NIX)
+    if (MSVC)
+      set(PYTHON_VER "python")
+    else()
+      set(PYTHON_VER "python3")
+    endif()
+    add_test(
+      NAME test-tolk
+      COMMAND ${PYTHON_VER} tolk-tester.py tests/
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tolk-tester)
+    if (WIN32)
+        set_property(TEST test-tolk PROPERTY ENVIRONMENT
+          "TOLK_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/tolk/tolk.exe"
+          "FIFT_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/fift.exe"
+          "FIFTPATH=${CMAKE_CURRENT_SOURCE_DIR}/crypto/fift/lib/")
+    else()
+        set_property(TEST test-tolk PROPERTY ENVIRONMENT
+          "TOLK_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/tolk/tolk"
+          "FIFT_EXECUTABLE=${CMAKE_CURRENT_BINARY_DIR}/crypto/fift"
+          "FIFTPATH=${CMAKE_CURRENT_SOURCE_DIR}/crypto/fift/lib/")
+    endif()
+endif()
+
 #BEGIN internal
 if (NOT TON_ONLY_TONLIB)
 add_test(test-adnl test-adnl)
 add_test(test-dht test-dht)
 add_test(test-rldp test-rldp)
 add_test(test-rldp2 test-rldp2)
-#add_test(test-validator-session-state test-validator-session-state)
+add_test(test-validator-session-state test-validator-session-state)
 add_test(test-catchain test-catchain)
 
 add_test(test-fec test-fec)
@@ -552,4 +672,3 @@ add_test(test-tddb test-tddb ${TEST_OPTIONS})
 add_test(test-db test-db ${TEST_OPTIONS})
 endif()
 #END internal
-

Changelog.md

@@ -0,0 +1,265 @@
+## 2025.03 Update
+1. New extracurrency behavior introduced, check [GlobalVersions.md](./doc/GlobalVersions.md#version-10)
+2. Optmization of validation process, in particular CellStorageStat.
+3. Flag for speeding up broadcasts in various overlays.
+4. Fixes for static builds for emulator and tonlibjson
+5. Improving getstats output: adds
+  * Liteserver queries count
+  * Collated/validated blocks count, number of active sessions
+  * Persistent state sizes
+  * Initial sync progress
+6. Fixes in logging, TON Storage, external message checking, persistent state downloading, UB in tonlib
+
+Besides the work of the core team, this update is based on the efforts of  @Sild from StonFi(UB in tonlib).
+
+## 2025.02 Update
+1. Series of improvement/fixes for `Config8.version >= 9`, check [GlobalVersions.md](./doc/GlobalVersions.md)
+2. Fix for better discovery of updated nodes' (validators') IPs: retry dht queries
+3. Series of improvements for extra currency adoption: fixed c7 in rungetmethod, reserve modes
+4. TVM: Fix processing continuation control data on deep jump
+5. A few fixes of tl-b schemes: crc computation, incorrect tag for merkle proofs, advance_ext, NatWidth print
+6. Emulator improvements: fix setting libraries,  extracurrency support
+7. Increase of gas limit for unlocking highload-v2 wallets locked in the beginning of 2024
+8. Validator console improvement: dashed names, better shard formats
+
+
+Besides the work of the core team, this update is based on the efforts of  @dbaranovstonfi from StonFi(libraries in emulator), @Rexagon (ret on deep jumps), @tvorogme from DTon (`advance_ext`), Nan from Zellic (`stk_und` and JNI)
+
+## 2024.12 Update
+
+1. FunC 0.4.6: Fix in try/catch handling, fixing pure flag for functions stored in variables
+2. Merging parts of Accelerator: support of specific shard monitoring, archive/liteserver slice format, support for partial liteservers, proxy liteserver, on-demand neighbour queue loading
+3. Fix of asynchronous cell loading
+4. Various improvements: caching certificates checks, better block overloading detection, `_malloc` in emulator
+5. Introduction of telemetry in overlays
+6. Use non-null local-id for tonlib-LS interaction - mitigates MitM attack.
+7. Adding `SECP256K1_XONLY_PUBKEY_TWEAK_ADD`, `SETCONTCTRMANY` instructions to TVM (activated by `Config8.version >= 9`)
+8. Private keys export via validator-engine-console - required for better backups
+9. Fix proof checking in tonlib, `hash` in `raw.Message` in tonlib_api
+
+Besides the work of the core team, this update is based on the efforts of OtterSec and LayerZero (FunC), tg:@throwunless (FunC), Aviv Frenkel and Dima Kogan from Fordefi (LS MitM), @hacker-volodya (Tonlib), OKX team (async cell loading), @krigga (emulator)
+
+## 2024.10 Update
+
+1. Parallel write to celldb: substantial improvement of sync and GC speed, especially with slow disks.
+2. Decreased network traffic: only first block candidate is sent optimistically.
+3. Improved channel creation and dht lookups, introduction of semi-private overlays
+4. New LS dispatch queue related methods and improvement security
+5. Fixing recursion in TVM continuations
+6. Improved stats for actors, validator sessions, perf counters, overlays, adnl, rocksdb
+7. Migration to C++20
+8. Improved block size estimates: account for depth in various structures
+9. Fix bug with `<<` optimization in FunC
+10. Minor changes of TVM which will be activated by `Config8.version >= 9`
+11. Multiple minor improvements
+
+Besides the work of the core team, this update is based on the efforts of @krigga (emulator), Arayz @ TonBit (LS security, TVM recursion), @ret2happy (UB in BLST).
+
+## 2024.08 Update
+
+1. Introduction of dispatch queues, message envelopes with transaction chain metadata, and explicitly stored msg_queue size, which will be activated by `Config8.version >= 8` and new `Config8.capabilities` bits: `capStoreOutMsgQueueSize`, `capMsgMetadata`, `capDeferMessages`. 
+2. A number of changes to transaction executor which will activated for `Config8.version >= 8`:
+    - Check mode on invalid `action_send_msg`. Ignore action if `IGNORE_ERROR` (+2) bit is set, bounce if `BOUNCE_ON_FAIL` (+16) bit is set.
+    - Slightly change random seed generation to fix mix of `addr_rewrite` and `addr`.
+    - Fill in `skipped_actions` for both invalid and valid messages with `IGNORE_ERROR` mode that can't be sent.
+    - Allow unfreeze through external messages.
+    - Don't use user-provided `fwd_fee` and `ihr_fee` for internal messages.
+3. A few issues with broadcasts were fixed: stop on receiving last piece, response to AdnlMessageCreateChannel
+4. A number of fixes and improvements for emulator and tonlib: correct work with config_addr, not accepted externals, bounces, debug ops gas consumption, added version and c5 dump, fixed tonlib crashes
+5. Added new flags and commands to the node, in particular `--fast-state-serializer`, `getcollatoroptionsjson`, `setcollatoroptionsjson`
+
+Besides the work of the core team, this update is based on the efforts of @krigga (emulator), stonfi team, in particular @dbaranovstonfi and @hey-researcher (emulator), and  @loeul, @xiaoxianBoy, @simlecode (typos in comments and docs).
+
+
+
+## 2024.06 Update
+
+1. Make Jemalloc default allocator
+2. Add candidate broadcasting and caching
+3. Limit per address speed for external messages broadcast by reasonably large number 
+4. Overlay improvements: fix dropping peers in small custom overlays, fix wrong certificate on missed keyblocks
+5. Extended statistics and logs for celldb usage, session stats, persistent state serialization
+6. Tonlib and explorer fixes
+7. Flags for precize control of Celldb: `--celldb-cache-size`, `--celldb-direct-io` and `--celldb-preload-all`
+8. Add valiator-console command to stop persistent state serialization
+9. Use `@` path separator for defining include path in fift and create-state utilities on Windows only.
+
+
+## 2024.04 Update
+
+1. Emulator: Single call optimized runGetMethod added
+2. Tonlib: a series of proof improvements, also breaking Change in `liteServer.getAllShardsInfo` method (see below)
+3. DB: usage statistics now collected, outdated persistent states are not serialized
+4. LS: fast `getOutMsgQueueSizes` added, preliminary support of non-final block requests
+5. Network: lz4 compression of block candidates (disabled by default).
+6. Overlays: add custom overlays
+7. Transaction Executor: fixed issue with due_payment collection
+
+* `liteServer.getAllShardsInfo` method was updated for better efficiency. Previously, field proof contained BoC with two roots: one for BlockState from block's root and another for ShardHashes from BlockState. Now, it returns a single-root proof BoC, specifically the merkle proof of ShardHashes directly from the block's root, streamlining data access and integrity. Checking of the proof requires to check that ShardHashes in the `data` correspond to ShardHashes from the block.
+
+Besides the work of the core team, this update is based on the efforts of @akifoq (due_payment issue).
+
+## 2024.03 Update
+
+1. Preparatory (not enabled yet) code for pre-compiled smart-contract.
+2. Minor fixes for fee-related opcodes.
+
+## 2024.02 Update
+
+1. Improvement of validator synchronisation:
+   * Better handling of block broadcasts -> faster sync
+   * Additional separate overlay among validators as second option for synchronisation
+2. Improvements in LS:
+   * c7 and library context is fully filled up for server-side rungetmethod
+   * Cache for runmethods and successfull external messages
+   * Logging of LS requests statistic
+3. Precise control of open files:
+   * almost instantaneous validator start
+   * `--max-archive-fd` option
+   * autoremoval of not used temp archive files
+   * `--archive-preload-period` option
+4. Preparatory (not enabled yet) code for addition on new TVM instructions for cheaper fee calculation onchain.
+
+## 2024.01 Update
+
+1. Fixes in how gas in transactions on special accounts is accounted in block limit. Previously, gas was counted as usual, so to conduct elections that costs >30m gas block limit in masterchain was set to 37m gas. To lower the limit for safety reasons it is proposed to caunt gas on special accounts separately. Besides `gas_max` is set to `special_gas_limit` for all types of transactions on special accounts. New behavior is activated through setting `version >= 5` in `ConfigParam 8;`.
+   * Besides update of config temporally increases gas limit on `EQD_v9j1rlsuHHw2FIhcsCFFSD367ldfDdCKcsNmNpIRzUlu` to `special_gas_limit`, see [details](https://t.me/tonstatus/88).
+2. Improvements in LS behavior
+   * Improved detection of the state with all shards applied to decrease rate of `Block is not applied` error
+   * Better error logs: `block not in db` and `block is not applied` separation
+   * Fix error in proof generation for blocks after merge
+   * Fix most of `block is not applied` issues related to sending too recent block in Proofs
+   * LS now check external messages till `accept_message` (`set_gas`).
+3. Improvements in DHT work and storage, CellDb, config.json amendment, peer misbehavior detection, validator session stats collection, emulator.
+4. Change in CTOS and XLOAD behavior activated through setting `version >= 5` in `ConfigParam 8;`:
+   * Loading "nested libraries" (i.e. a library cell that points to another library cell) throws an exception.
+   * Loading a library consumes gas for cell load only once (for the library cell), not twice (both for the library cell and the cell in the library).
+   * `XLOAD` now works differently. When it takes a library cell, it returns the cell that it points to. This allows loading "nested libraries", if needed.
+
+Besides the work of the Core team, this update is based on the efforts of @XaBbl4 (peer misbehavior detection) and @akifoq (CTOS behavior and gas limit scheme for special accounts).
+
+## 2023.12 Update
+
+1. Optimized message queue handling, now queue cleaning speed doesn't depend on total queue size
+     * Cleaning delivered messages using lt augmentation instead of random search / consecutive walk
+     * Keeping root cell of queue message in memory until outdated (caching)
+2. Changes to block collation/validation limits
+3. Stop accepting new external message if message queue is overloaded
+4. Introducing conditions for shard split/merge based on queue size
+
+Read [more](https://blog.ton.org/technical-report-december-5-inscriptions-launch-on-ton) on that update.
+
+## 2023.11 Update
+
+1. New TVM Functionality. (Disabled by default)
+2. A series of emulator improvements: libraries support, higher max stack size, etc
+3. A series of tonlib and tonlib-cli improvements: wallet-v4 support, getconfig, showtransactions, etc
+4. Changes to public libraries: now contract can not publish more than 256 libraries (config parameter) and contracts can not be deployed with public libraries in initstate (instead contracts need explicitly publish all libraries)
+5. Changes to storage due payment: now due payment is collected in Storage Phase, however for bouncable messages fee amount can not exceed balance of account prior to message.
+
+
+Besides the work of the core team, this update is based on the efforts of @aleksej-paschenko (emulator improvements), @akifoq (security improvements), Trail of Bits auditor as well as all participants of [TEP-88 discussion](https://github.com/ton-blockchain/TEPs/pull/88).
+
+## 2023.10 Update
+1. A series of additional security checks in node: special cells in action list, init state in external messages, peers data prior to saving to disk.
+2. Human-readable timestamps in explorer
+
+Besides the work of the core team, this update is based on the efforts of @akifoq and @mr-tron.
+
+## 2023.06 Update
+1. (disabled by default) New deflation mechanisms: partial fee burning and blackhole address
+2. Storage-contract improvement
+
+Besides the work of the core team, this update is based on the efforts of @DearJohnDoe from Tonbyte (Storage-contract improvement).
+
+## 2023.05 Update
+1. Archive manager optimization
+2. A series of catchain (basic consensus protocol) security improvements
+3. Update for Fift libraries and FunC: better error-handling, fixes for `catch` stack recovery
+4. A series of out message queue handling optimization (already deployed during emergency upgrades between releases)
+5. Improvement of binaries portability
+
+Besides the work of the core team, this update is based on the efforts of @aleksej-paschenko (portability improvement), [Disintar team](https://github.com/disintar/) (archive manager optimization) and [sec3-service](https://github.com/sec3-service) security auditors (funC improvements).
+
+## 2023.04 Update
+1. CPU load optimization: previous DHT reconnect policy was too aggressive
+2. Network throughput improvements: granular control on external message broadcast, optimize celldb GC, adjust state serialization and block downloading timings, rldp2 for states and archives 
+3. Update for Fift (namespaces) and Fift libraries (list of improvements: https://github.com/ton-blockchain/ton/issues/631)
+4. Better handling of incorrect inputs in funC: fix UB and prevent crashes on some inputs, improve optimizing int consts and unused variables in FunC, fix analyzing repeat loop. FunC version is increase to 0.4.3.
+5. `listBlockTransactionsExt` in liteserver added
+6. Tvm emulator improvements
+
+Besides the work of the core team, this update is based on the efforts of @krigga (tvm emulator improvement), @ex3ndr (`PUSHSLICE` fift-asm improvement) and [sec3-service](https://github.com/sec3-service) security auditors (funC improvements).
+
+## 2023.03 Update
+1. Improvement of ADNL connection stability
+2. Transaction emulator support and getAccountStateByTransaction method
+3. Fixes of typos, undefined behavior and timer warnings
+4. Handling incorrect integer literal values in funC; funC version bumped to 0.4.2
+5. FunC Mathlib
+
+## 2023.01 Update
+1. Added ConfigParam 44: `SuspendedAddressList`. Upon being set this config suspends initialisation of **uninit** addresses from the list for given time.
+2. FunC: `v0.4.1` added pragmas for precise control of computation order
+3. FunC: fixed compiler crashes for some exotic inputs
+4. FunC: added legacy tester, a collection of smart-contracts which is used to check whether compilator update change compilation result
+5. Improved archive manager: proper handling of recently garbage-collected blocks
+
+## 2022.12 Update
+Node update:
+1. Improvements of ton-proxy: fixed few bugs, improved stability
+2. Improved collator/validator checks, added optimization of storage stat calculation, generation and validation of new blocks is made safer
+3. Some previously hard-coded parameters such as split/merge timings, max sizes and depths of internal and external messages, and others now can be updated by validators through setting ConfigParams. Max contract size added to configs.
+4. Tonlib: updated raw.getTransactions (now it contains InitState), fixed long bytestrings truncation
+5. abseil-cpp is updated to newer versions
+6. Added configs for Token Bridge
+7. LiteServers: a few bug fixes, added liteServer.getAccountStatePrunned method, improved work with not yet applied blocks.
+8. Improved DHT: works for some NAT configurations, optimized excessive requests, added option for DHT network segregation.
+9. FunC v0.4.0: added try/catch statements, added throw_arg functions, allowed in-place modification of global variables, forbidden ambiguous modification of local variables after it's usage in the same expression.
+10. TON Storage: added storage-daemon (create, download bag of Files, storage-provider staff), added storage-daemon-cli
+
+Besides the work of the core team, this update is based on the efforts of @vtamara (help with abseil-cpp upgrade), @krigga(in-place modification of global variables) and third-party security auditors.
+
+## 2022.10 Update
+* Added extended block creation and general perfomance stats gathering
+* Forbidden report data on blocks not committed to the master chain for LS
+* Improved debug in TVM
+* FunC 0.3.0: multi-line asms, bitwise operations for constants, duplication of identical definition for constants and asms now allowed
+* New tonlib methods: sendMessageReturnHash, getTransactionsV2, getMasterchainBlockSignatures, getShardBlockProof, getLibraries.
+* Fixed bugs related to invalid TVM output (c4, c5, libaries) and non-validated network data; avoided too deep recursion in libraries loading
+* Fixed multiple undefined behavior issues
+* Added build of FunC and Fift to WASM
+
+Besides the work of the core team, this update is based on the efforts of @tvorogme (debug improvements), @AlexeyFSL (WASM builds)  and third-party security auditors.
+
+## 2022.08 Update
+* Blockchain state serialization now works via separate db-handler which simplifies memory clearing after serialization
+* CellDB now works asynchronously which substantially increase database access throughput
+* Abseil-cpp and crc32 updated: solve issues with compilation on recent OS distributives
+* Fixed a series of UBs and issues for exotic endianness hosts
+* Added detailed network stats for overlays (can be accessed via `validator-console`)
+* Improved auto-builds for wide range of systems.
+* Added extended error information for unaccepted external messages: `exit_code` and TVM trace (where applicable).
+* [Improved catchain DoS resistance](https://github.com/ton-blockchain/ton/blob/master/doc/catchain-dos.md)
+* A series of FunC improvements, summarized [here](https://github.com/ton-blockchain/ton/pull/378)
+#### Update delay
+Update coincided with persistent state serialization event which lead to block production speed deterioration (issue substantially mitigated in update itself). This phenomena was aggravated by the fact that after update some validators lost ability to participate in block creation. The last was caused by threshold based hardcoded protocol version bump, where threshold was set in such manner (based on block height with value higher than 9m), that it eluded detection in private net tests. The update was temporarily paused and resumed after persistent state serialization ended and issues with block creation were resolved.
+
+Besides the work of the core team, this update is based on the efforts of @awesome-doge (help with abseil-cpp upgrade), @rec00rsiff (noted issues for exotic endianess and implemented network stats) and third-party security auditors.
+
+## 2022.05 Update
+* Initial synchronization improved: adjusted timeouts for state download and the way of choosing which state to download. Nodes with low network speed and/or bad connectivity will synchronize faster and consistently.
+* Improved peer-to-peer network stability and DDoS resistance: now peers will only relay valid messages to the network. Large messages, which require splitting for relaying, will be retranslated as well, but only after the node gets all parts, and reassembles and checks them. Validators may sign certificates for network peers, which allow relaying large messages by parts without checks. It is used now by validators to faster relay new blocks. Sign and import certificate commands are exposed via `validator-engine-console`.
+* Fixed some rare edge cases in TVM arithmetic operations related to big numbers (`2**63+`)
+* Improved fixes used to combat wrong activate-destruct-activate contract behavior last November.
+* Improved tonlib: support libraries (with client-side caching), getmethods completely fill c7 register, getmethods support slice arguments, improved messages listing for transactions, added extended block header params, added getConfig method.
+* RocksDB updated to a newer version.
+* Improved persistent state serialization: memory usage during serialization was optimized; the start of serialization on different nodes was sparsed.
+* FunC update: support for string literals and constants (including precompiled constant expressions), semver, `include` expressions.
+* Fixed rarely manifested bugs in `Asm.fif`.
+* LiteClient supports key as cli parameter.
+* Improved Liteserver DoS resistance for running getmethods.
+
+Besides the work of the core team, this update is based on the efforts of @tvorogme (added support for slice arguments and noted bugs in Asm.fif), @akifoq (fixed bug in Asm.fif), @cryshado (noted strange behavior of LS, which, upon inspection, turned out to be a vector of DoS attack).
+
+

Dockerfile

@@ -0,0 +1,69 @@
+FROM ubuntu:22.04 AS builder
+ARG DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && \
+        rm /var/lib/dpkg/info/libc-bin.* && \
+        apt-get clean && \
+        apt-get update && \
+        apt install libc-bin && \
+        apt-get install -y build-essential cmake clang openssl libssl-dev zlib1g-dev gperf wget git \
+        ninja-build libsodium-dev libmicrohttpd-dev liblz4-dev pkg-config autoconf automake libtool \
+        libjemalloc-dev lsb-release software-properties-common gnupg
+
+RUN wget https://apt.llvm.org/llvm.sh && \
+    chmod +x llvm.sh && \
+    ./llvm.sh 16 all && \
+    rm -rf /var/lib/apt/lists/*
+
+ENV CC=/usr/bin/clang-16
+ENV CXX=/usr/bin/clang++-16
+ENV CCACHE_DISABLE=1
+
+WORKDIR /
+RUN mkdir ton
+WORKDIR /ton
+
+COPY ./ ./
+
+RUN mkdir build && \
+        cd build && \
+        cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DPORTABLE=1 -DTON_ARCH= -DTON_USE_JEMALLOC=ON .. && \
+        ninja storage-daemon storage-daemon-cli tonlibjson fift func validator-engine validator-engine-console \
+    generate-random-id dht-server lite-client tolk rldp-http-proxy dht-server proxy-liteserver create-state \
+    blockchain-explorer emulator tonlibjson http-proxy adnl-proxy
+
+FROM ubuntu:22.04
+ARG DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && \
+    apt-get install -y wget curl libatomic1 openssl libsodium-dev libmicrohttpd-dev liblz4-dev libjemalloc-dev htop \
+    net-tools netcat iptraf-ng jq tcpdump pv plzip && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /var/ton-work/db /var/ton-work/scripts /usr/share/ton/smartcont/auto /usr/lib/fift/
+
+COPY --from=builder /ton/build/storage/storage-daemon/storage-daemon /usr/local/bin/
+COPY --from=builder /ton/build/storage/storage-daemon/storage-daemon-cli /usr/local/bin/
+COPY --from=builder /ton/build/lite-client/lite-client /usr/local/bin/
+COPY --from=builder /ton/build/validator-engine/validator-engine /usr/local/bin/
+COPY --from=builder /ton/build/validator-engine-console/validator-engine-console /usr/local/bin/
+COPY --from=builder /ton/build/utils/generate-random-id /usr/local/bin/
+COPY --from=builder /ton/build/blockchain-explorer/blockchain-explorer /usr/local/bin/
+COPY --from=builder /ton/build/crypto/create-state /usr/local/bin/
+COPY --from=builder /ton/build/utils/proxy-liteserver /usr/local/bin/
+COPY --from=builder /ton/build/dht-server/dht-server /usr/local/bin/
+COPY --from=builder /ton/build/rldp-http-proxy/rldp-http-proxy /usr/local/bin/
+COPY --from=builder /ton/build/http/http-proxy  /usr/local/bin/
+COPY --from=builder /ton/build/adnl/adnl-proxy  /usr/local/bin/
+COPY --from=builder /ton/build/tonlib/libtonlibjson.so /usr/local/bin/
+COPY --from=builder /ton/build/emulator/libemulator.so /usr/local/bin/
+COPY --from=builder /ton/build/tolk/tolk /usr/local/bin/
+COPY --from=builder /ton/build/crypto/fift /usr/local/bin/
+COPY --from=builder /ton/build/crypto/func /usr/local/bin/
+COPY --from=builder /ton/crypto/smartcont/* /usr/share/ton/smartcont/
+COPY --from=builder /ton/crypto/smartcont/auto/* /usr/share/ton/smartcont/auto/
+COPY --from=builder /ton/crypto/fift/lib/* /usr/lib/fift/
+
+WORKDIR /var/ton-work/db
+COPY ./docker/init.sh ./docker/control.template /var/ton-work/scripts/
+RUN chmod +x /var/ton-work/scripts/init.sh
+
+ENTRYPOINT ["/var/ton-work/scripts/init.sh"]

README.md

@@ -0,0 +1,151 @@
+<div align="center">
+  <a href="https://ton.org">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://ton.org/download/ton_logo_dark_background.svg">
+      <img alt="TON logo" src="https://ton.org/download/ton_logo_light_background.svg">
+    </picture>
+  </a>
+  <h3>Reference implementation of TON Node and tools</h3>
+  <hr/>
+</div>
+
+## 
+
+<p align="center">
+  <a href="https://tonresear.ch">
+    <img src="https://img.shields.io/badge/TON%20Research-0098EA?style=flat&logo=discourse&label=Forum&labelColor=gray" alt="Ton Research">
+  </a>
+  <a href="https://t.me/toncoin">
+    <img src="https://img.shields.io/badge/TON%20Community-0098EA?logo=telegram&logoColor=white&style=flat" alt="Telegram Community Group">
+  </a>
+  <a href="https://t.me/tonblockchain">
+    <img src="https://img.shields.io/badge/TON%20Foundation-0098EA?logo=telegram&logoColor=white&style=flat" alt="Telegram Foundation Group">
+  </a>
+  <a href="https://t.me/tondev_eng">
+    <img src="https://img.shields.io/badge/chat-TONDev-0098EA?logo=telegram&logoColor=white&style=flat" alt="Telegram Community Chat">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://twitter.com/ton_blockchain">
+    <img src="https://img.shields.io/twitter/follow/ton_blockchain" alt="Twitter Group">
+  </a>
+  <a href="https://answers.ton.org">
+    <img src="https://img.shields.io/badge/-TON%20Overflow-FE7A16?style=flat&logo=stack-overflow&logoColor=white" alt="TON Overflow Group">
+  </a>
+  <a href="https://stackoverflow.com/questions/tagged/ton">
+    <img src="https://img.shields.io/badge/-Stack%20Overflow-FE7A16?style=flat&logo=stack-overflow&logoColor=white" alt="Stack Overflow Group">
+  </a>
+</p>
+
+
+
+Main TON monorepo, which includes the code of the node/validator, lite-client, tonlib, FunC compiler, etc.
+
+## The Open Network
+
+__The Open Network (TON)__ is a fast, secure, scalable blockchain focused on handling _millions of transactions per second_ (TPS) with the goal of reaching hundreds of millions of blockchain users.
+- To learn more about different aspects of TON blockchain and its underlying ecosystem check [documentation](https://ton.org/docs)
+- To run node, validator or lite-server check [Participate section](https://ton.org/docs/participate/nodes/run-node)
+- To develop decentralised apps check [Tutorials](https://docs.ton.org/v3/guidelines/smart-contracts/guidelines), [FunC docs](https://ton.org/docs/develop/func/overview) and [DApp tutorials](https://docs.ton.org/v3/guidelines/dapps/overview)
+- To work on TON check [wallets](https://ton.app/wallets), [explorers](https://ton.app/explorers), [DEXes](https://ton.app/dex) and [utilities](https://ton.app/utilities)
+- To interact with TON check [APIs](https://docs.ton.org/v3/guidelines/dapps/apis-sdks/overview)
+
+## Updates flow
+
+* **master branch** - mainnet is running on this stable branch.
+
+    Only emergency updates, urgent updates, or updates that do not affect the main codebase (GitHub workflows / docker images / documentation) are committed directly to this branch.
+
+* **testnet branch** - testnet is running on this branch. The branch contains a set of new updates. After testing, the testnet branch is merged into the master branch and then a new set of updates is added to testnet branch.
+
+* **backlog** - other branches that are candidates to getting into the testnet branch in the next iteration.
+
+Usually, the response to your pull request will indicate which section it falls into.
+
+
+## "Soft" Pull Request rules
+
+* Thou shall not merge your own PRs, at least one person should review the PR and merge it (4-eyes rule)
+* Thou shall make sure that workflows are cleanly completed for your PR before considering merge
+
+## Build TON blockchain
+
+### Ubuntu 20.4, 22.04, 24.04 (x86-64, aarch64)
+Install additional system libraries
+```bash
+  sudo apt-get update
+  sudo apt-get install -y build-essential git cmake ninja-build zlib1g-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev
+          
+  wget https://apt.llvm.org/llvm.sh
+  chmod +x llvm.sh
+  sudo ./llvm.sh 16 all
+```
+Compile TON binaries
+```bash
+  cp assembly/native/build-ubuntu-shared.sh .
+  chmod +x build-ubuntu-shared.sh
+  ./build-ubuntu-shared.sh  
+```
+
+### MacOS 11, 12 (x86-64, aarch64)
+```bash
+  cp assembly/native/build-macos-shared.sh .
+  chmod +x build-macos-shared.sh
+  ./build-macos-shared.sh
+```
+
+### Windows 10, 11, Server (x86-64)
+You need to install `MS Visual Studio 2022` first.
+Go to https://www.visualstudio.com/downloads/ and download `MS Visual Studio 2022 Community`.
+
+Launch installer and select `Desktop development with C++`. 
+After installation, also make sure that `cmake` is globally available by adding
+`C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin` to the system `PATH` (adjust the path per your needs).
+
+Open an elevated (Run as Administrator) `x86-64 Native Tools Command Prompt for VS 2022`, go to the root folder and execute: 
+```bash
+  copy assembly\native\build-windows.bat .
+  build-windows.bat
+```
+
+### Building TON to WebAssembly
+Install additional system libraries on Ubuntu
+```bash
+  sudo apt-get update
+  sudo apt-get install -y build-essential git cmake ninja-build zlib1g-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev
+          
+  wget https://apt.llvm.org/llvm.sh
+  chmod +x llvm.sh
+  sudo ./llvm.sh 16 all
+```
+Compile TON binaries with emscripten
+```bash
+  cd assembly/wasm
+  chmod +x fift-func-wasm-build-ubuntu.sh
+  ./fift-func-wasm-build-ubuntu.sh
+```
+
+### Building TON tonlib library for Android (arm64-v8a, armeabi-v7a, x86, x86-64)
+Install additional system libraries on Ubuntu
+```bash
+  sudo apt-get update
+  sudo apt-get install -y build-essential git cmake ninja-build automake libtool texinfo autoconf libgflags-dev \
+  zlib1g-dev libssl-dev libreadline-dev libmicrohttpd-dev pkg-config libgsl-dev python3 python3-dev \
+  libtool autoconf libsodium-dev libsecp256k1-dev
+```
+Compile TON tonlib library
+```bash
+  cp assembly/android/build-android-tonlib.sh .
+  chmod +x build-android-tonlib.sh
+  ./build-android-tonlib.sh
+```
+
+### TON portable binaries
+
+Linux portable binaries are wrapped into AppImages, at the same time MacOS portable binaries are statically linked executables.
+Linux and MacOS binaries are available for both x86-64 and arm64 architectures. 
+
+## Running tests
+
+Tests are executed by running `ctest` in the build directory. See `doc/Tests.md` for more information.

adnl/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
 
 #BEGIN internal
 if (NOT TON_ONLY_TONLIB)
@@ -88,21 +88,21 @@ target_link_libraries(adnl PUBLIC tdactor ton_crypto tl_api tdnet tddb keys keyr
 
 add_executable(adnl-proxy ${ADNL_PROXY_SOURCE})
 target_include_directories(adnl-proxy PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>)
-target_link_libraries(adnl-proxy PUBLIC tdactor ton_crypto tl_api tdnet common
-  tl-utils)
+target_link_libraries(adnl-proxy PUBLIC tdactor ton_crypto tl_api tdnet common tl-utils git)
 
 add_executable(adnl-pong adnl-pong.cpp)
 target_include_directories(adnl-pong PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>)
-target_link_libraries(adnl-pong PUBLIC tdactor ton_crypto tl_api tdnet common
-  tl-utils adnl dht)
+target_link_libraries(adnl-pong PUBLIC tdactor ton_crypto tl_api tdnet common tl-utils adnl dht git)
 
 add_library(adnltest STATIC ${ADNL_TEST_SOURCE})
 target_include_directories(adnltest PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>)
-target_link_libraries(adnltest PUBLIC adnl )
+target_link_libraries(adnltest PUBLIC adnl)
+
+install(TARGETS adnl-proxy RUNTIME DESTINATION bin)
 endif()
 #END internal
 
 add_library(adnllite STATIC ${ADNL_LITE_SOURCE})
 
 target_include_directories(adnllite PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>)
-target_link_libraries(adnllite PUBLIC tdactor ton_crypto tl_lite_api tdnet keys )
+target_link_libraries(adnllite PUBLIC tdactor ton_crypto tl_lite_api tdnet keys)

adnl/adnl-address-list.cpp

@@ -39,6 +39,9 @@ class AdnlNetworkConnectionUdp : public AdnlNetworkConnection {
   void start_up() override {
     callback_->on_change_state(true);
   }
+  void get_ip_str(td::Promise<td::string> promise) override {
+    promise.set_value(PSTRING() << addr_.get_ip_str().str() << ":" << addr_.get_port());
+  }
 
   AdnlNetworkConnectionUdp(td::actor::ActorId<AdnlNetworkManager> network_manager, td::uint32 ip, td::uint16 port,
                            std::unique_ptr<AdnlNetworkConnection::Callback> callback);
@@ -88,6 +91,9 @@ class AdnlNetworkConnectionTunnel : public AdnlNetworkConnection {
     pub_key_hash_ = pub_key_.compute_short_id();
     //ready_.store(true, std::memory_order_release);
   }
+  void get_ip_str(td::Promise<td::string> promise) override {
+    promise.set_value("tunnel");
+  }
 
   AdnlNetworkConnectionTunnel(td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
                               adnl::AdnlNodeIdShort adnl_id, PublicKey pubkey,
@@ -179,7 +185,8 @@ td::Ref<AdnlAddressImpl> AdnlAddressImpl::create(const tl_object_ptr<ton_api::ad
       *const_cast<ton_api::adnl_Address *>(addr.get()),
       td::overloaded([&](const ton_api::adnl_address_udp &obj) { res = td::make_ref<AdnlAddressUdp>(obj); },
                      [&](const ton_api::adnl_address_udp6 &obj) { res = td::make_ref<AdnlAddressUdp6>(obj); },
-                     [&](const ton_api::adnl_address_tunnel &obj) { res = td::make_ref<AdnlAddressTunnel>(obj); }));
+                     [&](const ton_api::adnl_address_tunnel &obj) { res = td::make_ref<AdnlAddressTunnel>(obj); },
+                     [&](const ton_api::adnl_address_reverse &obj) { res = td::make_ref<AdnlAddressReverse>(); }));
   return res;
 }
 
@@ -196,7 +203,12 @@ AdnlAddressList::AdnlAddressList(const tl_object_ptr<ton_api::adnl_addressList>
   version_ = static_cast<td::uint32>(addrs->version_);
   std::vector<td::Ref<AdnlAddressImpl>> vec;
   for (auto &addr : addrs->addrs_) {
-    vec.push_back(AdnlAddressImpl::create(addr));
+    auto obj = AdnlAddressImpl::create(addr);
+    if (obj->is_reverse()) {
+      has_reverse_ = true;
+    } else {
+      vec.push_back(std::move(obj));
+    }
   }
   addrs_ = std::move(vec);
   reinit_date_ = addrs->reinit_date_;
@@ -209,6 +221,9 @@ tl_object_ptr<ton_api::adnl_addressList> AdnlAddressList::tl() const {
   for (auto &v : addrs_) {
     addrs.emplace_back(v->tl());
   }
+  if (has_reverse_) {
+    addrs.push_back(create_tl_object<ton_api::adnl_address_reverse>());
+  }
   return create_tl_object<ton_api::adnl_addressList>(std::move(addrs), version_, reinit_date_, priority_, expire_at_);
 }
 

adnl/adnl-address-list.h

@@ -39,6 +39,9 @@ class AdnlAddressImpl : public td::CntObject {
   virtual td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
       td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
       std::unique_ptr<AdnlNetworkConnection::Callback> callback) const = 0;
+  virtual bool is_reverse() const {
+    return false;
+  }
 
   static td::Ref<AdnlAddressImpl> create(const tl_object_ptr<ton_api::adnl_Address> &addr);
 };
@@ -54,6 +57,7 @@ class AdnlAddressList {
   td::int32 priority_;
   td::int32 expire_at_;
   std::vector<AdnlAddress> addrs_;
+  bool has_reverse_{false};
 
  public:
   static constexpr td::uint32 max_serialized_size() {
@@ -102,6 +106,13 @@ class AdnlAddressList {
 
   static td::Result<AdnlAddressList> create(const tl_object_ptr<ton_api::adnl_addressList> &addr_list);
   td::Status add_udp_address(td::IPAddress addr);
+
+  void set_reverse(bool x = true) {
+    has_reverse_ = x;
+  }
+  bool has_reverse() const {
+    return has_reverse_;
+  }
 };
 
 }  // namespace adnl

adnl/adnl-address-list.hpp

@@ -116,6 +116,31 @@ class AdnlAddressTunnel : public AdnlAddressImpl {
       std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override;
 };
 
+class AdnlAddressReverse : public AdnlAddressImpl {
+ public:
+  AdnlAddressReverse *make_copy() const override {
+    return new AdnlAddressReverse();
+  }
+  bool is_public() const override {
+    return true;
+  }
+  td::uint32 serialized_size() const override {
+    return 4;
+  }
+  tl_object_ptr<ton_api::adnl_Address> tl() const override {
+    return create_tl_object<ton_api::adnl_address_reverse>();
+  }
+  td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
+      td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
+      std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override {
+    LOG(ERROR) << "Cannot create connection for AdnlAddressReverse";
+    return {};
+  }
+  bool is_reverse() const override {
+    return true;
+  }
+};
+
 }  // namespace adnl
 
 }  // namespace ton

adnl/adnl-channel.cpp

@@ -112,16 +112,16 @@ void AdnlChannelImpl::send_message(td::uint32 priority, td::actor::ActorId<AdnlN
 }
 
 void AdnlChannelImpl::receive(td::IPAddress addr, td::BufferSlice data) {
-  auto P = td::PromiseCreator::lambda(
-      [peer = peer_pair_, channel_id = channel_in_id_, addr, id = print_id()](td::Result<AdnlPacket> R) {
-        if (R.is_error()) {
-          VLOG(ADNL_WARNING) << id << ": dropping IN message: can not decrypt: " << R.move_as_error();
-        } else {
-          auto packet = R.move_as_ok();
-          packet.set_remote_addr(addr);
-          td::actor::send_closure(peer, &AdnlPeerPair::receive_packet_from_channel, channel_id, std::move(packet));
-        }
-      });
+  auto P = td::PromiseCreator::lambda([peer = peer_pair_, channel_id = channel_in_id_, addr, id = print_id(),
+                                       size = data.size()](td::Result<AdnlPacket> R) {
+    if (R.is_error()) {
+      VLOG(ADNL_WARNING) << id << ": dropping IN message: can not decrypt: " << R.move_as_error();
+    } else {
+      auto packet = R.move_as_ok();
+      packet.set_remote_addr(addr);
+      td::actor::send_closure(peer, &AdnlPeerPair::receive_packet_from_channel, channel_id, std::move(packet), size);
+    }
+  });
 
   decrypt(std::move(data), std::move(P));
 }

adnl/adnl-ext-client.hpp

@@ -43,7 +43,10 @@ class AdnlOutboundConnection : public AdnlExtConnection {
  public:
   AdnlOutboundConnection(td::SocketFd fd, std::unique_ptr<AdnlExtConnection::Callback> callback, AdnlNodeIdFull dst,
                          td::actor::ActorId<AdnlExtClientImpl> ext_client)
-      : AdnlExtConnection(std::move(fd), std::move(callback), true), dst_(std::move(dst)), ext_client_(ext_client) {
+      : AdnlExtConnection(std::move(fd), std::move(callback), true)
+      , dst_(std::move(dst))
+      , local_id_(privkeys::Ed25519::random())
+      , ext_client_(ext_client) {
   }
   AdnlOutboundConnection(td::SocketFd fd, std::unique_ptr<AdnlExtConnection::Callback> callback, AdnlNodeIdFull dst,
                          PrivateKey local_id, td::actor::ActorId<AdnlExtClientImpl> ext_client)
@@ -80,6 +83,9 @@ class AdnlExtClientImpl : public AdnlExtClient {
     if (!conn_.empty() && conn_.get() == conn) {
       callback_->on_stop_ready();
       conn_ = {};
+      for (auto& q : out_queries_) {
+        td::actor::send_closure(q.second, &AdnlQuery::set_error, td::Status::Error(ErrorCode::cancelled));
+      }
       alarm_timestamp() = next_create_at_;
       try_stop();
     }

adnl/adnl-ext-server.cpp

@@ -91,7 +91,7 @@ td::Status AdnlInboundConnection::process_custom_packet(td::BufferSlice &data, b
     auto F = fetch_tl_object<ton_api::tcp_authentificate>(data.clone(), true);
     if (F.is_ok()) {
       if (nonce_.size() > 0 || !remote_id_.is_zero()) {
-        return td::Status::Error(ErrorCode::protoviolation, "duplicate authentificate");
+        return td::Status::Error(ErrorCode::protoviolation, "duplicate authenticate");
       }
       auto f = F.move_as_ok();
       nonce_ = td::SecureString{f->nonce_.size() + 256};

adnl/adnl-local-id.cpp

@@ -41,20 +41,34 @@ AdnlAddressList AdnlLocalId::get_addr_list() const {
 }
 
 void AdnlLocalId::receive(td::IPAddress addr, td::BufferSlice data) {
-  auto P = td::PromiseCreator::lambda(
-      [peer_table = peer_table_, dst = short_id_, addr, id = print_id()](td::Result<AdnlPacket> R) {
-        if (R.is_error()) {
-          VLOG(ADNL_WARNING) << id << ": dropping IN message: cannot decrypt: " << R.move_as_error();
-        } else {
-          auto packet = R.move_as_ok();
-          packet.set_remote_addr(addr);
-          td::actor::send_closure(peer_table, &AdnlPeerTable::receive_decrypted_packet, dst, std::move(packet));
-        }
-      });
-
+  InboundRateLimiter& rate_limiter = inbound_rate_limiter_[addr];
+  if (!rate_limiter.rate_limiter.take()) {
+    VLOG(ADNL_NOTICE) << this << ": dropping IN message: rate limit exceeded";
+    add_dropped_packet_stats(addr);
+    return;
+  }
+  ++rate_limiter.currently_decrypting_packets;
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), peer_table = peer_table_, dst = short_id_, addr,
+                                       id = print_id(), size = data.size()](td::Result<AdnlPacket> R) {
+    td::actor::send_closure(SelfId, &AdnlLocalId::decrypt_packet_done, addr);
+    if (R.is_error()) {
+      VLOG(ADNL_WARNING) << id << ": dropping IN message: cannot decrypt: " << R.move_as_error();
+    } else {
+      auto packet = R.move_as_ok();
+      packet.set_remote_addr(addr);
+      td::actor::send_closure(peer_table, &AdnlPeerTable::receive_decrypted_packet, dst, std::move(packet), size);
+    }
+  });
   decrypt(std::move(data), std::move(P));
 }
 
+void AdnlLocalId::decrypt_packet_done(td::IPAddress addr) {
+  auto it = inbound_rate_limiter_.find(addr);
+  CHECK(it != inbound_rate_limiter_.end());
+  --it->second.currently_decrypting_packets;
+  add_decrypted_packet_stats(addr);
+}
+
 void AdnlLocalId::deliver(AdnlNodeIdShort src, td::BufferSlice data) {
   auto s = std::move(data);
   for (auto &cb : cb_) {
@@ -121,7 +135,7 @@ void AdnlLocalId::update_address_list(AdnlAddressList addr_list) {
 }
 
 void AdnlLocalId::publish_address_list() {
-  if (dht_node_.empty() || addr_list_.empty() || addr_list_.size() == 0) {
+  if (dht_node_.empty() || addr_list_.empty() || (addr_list_.size() == 0 && !addr_list_.has_reverse())) {
     VLOG(ADNL_NOTICE) << this << ": skipping public addr list, because localid (or dht node) not fully initialized";
     return;
   }
@@ -175,6 +189,17 @@ void AdnlLocalId::publish_address_list() {
 
   td::actor::send_closure(keyring_, &keyring::Keyring::sign_message, short_id_.pubkey_hash(), std::move(B),
                           std::move(P));
+
+  if (addr_list_.has_reverse()) {
+    td::actor::send_closure(
+        dht_node_, &dht::Dht::register_reverse_connection, id_, [print_id = print_id()](td::Result<td::Unit> R) {
+          if (R.is_error()) {
+            VLOG(ADNL_NOTICE) << print_id << ": failed to register reverse connection in DHT: " << R.move_as_error();
+          } else {
+            VLOG(ADNL_INFO) << print_id << ": registered reverse connection";
+          }
+        });
+  }
 }
 
 AdnlLocalId::AdnlLocalId(AdnlNodeIdFull id, AdnlAddressList addr_list, td::uint32 mode,
@@ -281,6 +306,72 @@ void AdnlLocalId::update_packet(AdnlPacket packet, bool update_id, bool sign, td
   }
 }
 
+void AdnlLocalId::get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats_localId>> promise) {
+  auto stats = create_tl_object<ton_api::adnl_stats_localId>();
+  stats->short_id_ = short_id_.bits256_value();
+  for (auto &[ip, x] : inbound_rate_limiter_) {
+    if (x.currently_decrypting_packets != 0) {
+      stats->current_decrypt_.push_back(create_tl_object<ton_api::adnl_stats_ipPackets>(
+          ip.is_valid() ? PSTRING() << ip.get_ip_str() << ":" << ip.get_port() : "", x.currently_decrypting_packets));
+    }
+  }
+  prepare_packet_stats();
+  stats->packets_recent_ = packet_stats_prev_.tl();
+  stats->packets_total_ = packet_stats_total_.tl(all);
+  stats->packets_total_->ts_start_ = (double)Adnl::adnl_start_time();
+  stats->packets_total_->ts_end_ = td::Clocks::system();
+  promise.set_result(std::move(stats));
+}
+
+void AdnlLocalId::add_decrypted_packet_stats(td::IPAddress addr) {
+  prepare_packet_stats();
+  packet_stats_cur_.decrypted_packets[addr].inc();
+  packet_stats_total_.decrypted_packets[addr].inc();
+}
+
+void AdnlLocalId::add_dropped_packet_stats(td::IPAddress addr) {
+  prepare_packet_stats();
+  packet_stats_cur_.dropped_packets[addr].inc();
+  packet_stats_total_.dropped_packets[addr].inc();
+}
+
+void AdnlLocalId::prepare_packet_stats() {
+  double now = td::Clocks::system();
+  if (now >= packet_stats_cur_.ts_end) {
+    packet_stats_prev_ = std::move(packet_stats_cur_);
+    packet_stats_cur_ = {};
+    auto now_int = (int)td::Clocks::system();
+    packet_stats_cur_.ts_start = (double)(now_int / 60 * 60);
+    packet_stats_cur_.ts_end = packet_stats_cur_.ts_start + 60.0;
+    if (packet_stats_prev_.ts_end < now - 60.0) {
+      packet_stats_prev_ = {};
+      packet_stats_prev_.ts_end = packet_stats_cur_.ts_start;
+      packet_stats_prev_.ts_start = packet_stats_prev_.ts_end - 60.0;
+    }
+  }
+}
+
+tl_object_ptr<ton_api::adnl_stats_localIdPackets> AdnlLocalId::PacketStats::tl(bool all) const {
+  double threshold = all ? -1.0 : td::Clocks::system() - 600.0;
+  auto obj = create_tl_object<ton_api::adnl_stats_localIdPackets>();
+  obj->ts_start_ = ts_start;
+  obj->ts_end_ = ts_end;
+  for (const auto &[ip, packets] : decrypted_packets) {
+    if (packets.last_packet_ts >= threshold) {
+      obj->decrypted_packets_.push_back(create_tl_object<ton_api::adnl_stats_ipPackets>(
+          ip.is_valid() ? PSTRING() << ip.get_ip_str() << ":" << ip.get_port() : "", packets.packets));
+    }
+  }
+  for (const auto &[ip, packets] : dropped_packets) {
+    if (packets.last_packet_ts >= threshold) {
+      obj->dropped_packets_.push_back(create_tl_object<ton_api::adnl_stats_ipPackets>(
+          ip.is_valid() ? PSTRING() << ip.get_ip_str() << ":" << ip.get_port() : "", packets.packets));
+    }
+  }
+  return obj;
+}
+
+
 }  // namespace adnl
 
 }  // namespace ton

adnl/adnl-local-id.h

@@ -55,6 +55,7 @@ class AdnlLocalId : public td::actor::Actor {
   void deliver(AdnlNodeIdShort src, td::BufferSlice data);
   void deliver_query(AdnlNodeIdShort src, td::BufferSlice data, td::Promise<td::BufferSlice> promise);
   void receive(td::IPAddress addr, td::BufferSlice data);
+  void decrypt_packet_done(td::IPAddress addr);
 
   void subscribe(std::string prefix, std::unique_ptr<AdnlPeerTable::Callback> callback);
   void unsubscribe(std::string prefix);
@@ -77,6 +78,8 @@ class AdnlLocalId : public td::actor::Actor {
   void update_packet(AdnlPacket packet, bool update_id, bool sign, td::int32 update_addr_list_if,
                      td::int32 update_priority_addr_list_if, td::Promise<AdnlPacket> promise);
 
+  void get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats_localId>> promise);
+
   td::uint32 get_mode() {
     return mode_;
   }
@@ -101,6 +104,32 @@ class AdnlLocalId : public td::actor::Actor {
 
   td::uint32 mode_;
 
+  struct InboundRateLimiter {
+    RateLimiter rate_limiter = RateLimiter(75, 0.33);
+    td::uint64 currently_decrypting_packets = 0;
+  };
+  std::map<td::IPAddress, InboundRateLimiter> inbound_rate_limiter_;
+  struct PacketStats {
+    double ts_start = 0.0, ts_end = 0.0;
+
+    struct Counter {
+      td::uint64 packets = 0;
+      double last_packet_ts = 0.0;
+
+      void inc() {
+        ++packets;
+        last_packet_ts = td::Clocks::system();
+      }
+    };
+    std::map<td::IPAddress, Counter> decrypted_packets;
+    std::map<td::IPAddress, Counter> dropped_packets;
+
+    tl_object_ptr<ton_api::adnl_stats_localIdPackets> tl(bool all = true) const;
+  } packet_stats_cur_, packet_stats_prev_, packet_stats_total_;
+  void add_decrypted_packet_stats(td::IPAddress addr);
+  void add_dropped_packet_stats(td::IPAddress addr);
+  void prepare_packet_stats();
+
   void publish_address_list();
 };
 

adnl/adnl-network-manager.h

@@ -50,6 +50,8 @@ class AdnlNetworkConnection : public td::actor::Actor {
   virtual void send(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::uint32 priority, td::BufferSlice message) = 0;
   virtual bool is_alive() const = 0;
   virtual bool is_active() const = 0;
+
+  virtual void get_ip_str(td::Promise<td::string> promise) = 0;
   virtual ~AdnlNetworkConnection() = default;
 };
 

adnl/adnl-peer-table.cpp

@@ -84,7 +84,7 @@ void AdnlPeerTableImpl::receive_packet(td::IPAddress addr, AdnlCategoryMask cat_
                    << " (len=" << (data.size() + 32) << ")";
 }
 
-void AdnlPeerTableImpl::receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket packet) {
+void AdnlPeerTableImpl::receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket packet, td::uint64 serialized_size) {
   packet.run_basic_checks().ensure();
 
   if (!packet.inited_from_short()) {
@@ -119,7 +119,7 @@ void AdnlPeerTableImpl::receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket
     return;
   }
   td::actor::send_closure(it->second, &AdnlPeer::receive_packet, dst, it2->second.mode, it2->second.local_id.get(),
-                          std::move(packet));
+                          std::move(packet), serialized_size);
 }
 
 void AdnlPeerTableImpl::add_peer(AdnlNodeIdShort local_id, AdnlNodeIdFull id, AdnlAddressList addr_list) {
@@ -376,6 +376,97 @@ void AdnlPeerTableImpl::create_tunnel(AdnlNodeIdShort dst, td::uint32 size,
                                       td::Promise<std::pair<td::actor::ActorOwn<AdnlTunnel>, AdnlAddress>> promise) {
 }
 
+void AdnlPeerTableImpl::get_conn_ip_str(AdnlNodeIdShort l_id, AdnlNodeIdShort p_id, td::Promise<td::string> promise) {
+  auto it = peers_.find(p_id);
+  if (it == peers_.end()) {
+    promise.set_value("undefined");
+    return;
+  }
+  td::actor::send_closure(it->second, &AdnlPeer::get_conn_ip_str, l_id, std::move(promise));
+}
+
+void AdnlPeerTableImpl::get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats>> promise) {
+  class Cb : public td::actor::Actor {
+   public:
+    explicit Cb(td::Promise<tl_object_ptr<ton_api::adnl_stats>> promise) : promise_(std::move(promise)) {
+    }
+
+    void got_local_id_stats(tl_object_ptr<ton_api::adnl_stats_localId> local_id) {
+      auto &local_id_stats = local_id_stats_[local_id->short_id_];
+      if (local_id_stats) {
+        local_id->peers_ = std::move(local_id_stats->peers_);
+      }
+      local_id_stats = std::move(local_id);
+      dec_pending();
+    }
+
+    void got_peer_stats(std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>> peer_pairs) {
+      for (auto &peer_pair : peer_pairs) {
+        auto &local_id_stats = local_id_stats_[peer_pair->local_id_];
+        if (local_id_stats == nullptr) {
+          local_id_stats = create_tl_object<ton_api::adnl_stats_localId>();
+          local_id_stats->short_id_ = peer_pair->local_id_;
+        }
+        local_id_stats->peers_.push_back(std::move(peer_pair));
+      }
+      dec_pending();
+    }
+
+    void inc_pending() {
+      ++pending_;
+    }
+
+    void dec_pending() {
+      CHECK(pending_ > 0);
+      --pending_;
+      if (pending_ == 0) {
+        auto stats = create_tl_object<ton_api::adnl_stats>();
+        stats->timestamp_ = td::Clocks::system();
+        for (auto &[id, local_id_stats] : local_id_stats_) {
+          stats->local_ids_.push_back(std::move(local_id_stats));
+        }
+        promise_.set_result(std::move(stats));
+        stop();
+      }
+    }
+
+   private:
+    td::Promise<tl_object_ptr<ton_api::adnl_stats>> promise_;
+    size_t pending_ = 1;
+
+    std::map<td::Bits256, tl_object_ptr<ton_api::adnl_stats_localId>> local_id_stats_;
+  };
+  auto callback = td::actor::create_actor<Cb>("adnlstats", std::move(promise)).release();
+
+  for (auto &[id, local_id] : local_ids_) {
+    td::actor::send_closure(callback, &Cb::inc_pending);
+    td::actor::send_closure(local_id.local_id, &AdnlLocalId::get_stats, all,
+                            [id = id, callback](td::Result<tl_object_ptr<ton_api::adnl_stats_localId>> R) {
+                              if (R.is_error()) {
+                                VLOG(ADNL_NOTICE)
+                                    << "failed to get stats for local id " << id << " : " << R.move_as_error();
+                                td::actor::send_closure(callback, &Cb::dec_pending);
+                              } else {
+                                td::actor::send_closure(callback, &Cb::got_local_id_stats, R.move_as_ok());
+                              }
+                            });
+  }
+  for (auto &[id, peer] : peers_) {
+    td::actor::send_closure(callback, &Cb::inc_pending);
+    td::actor::send_closure(
+        peer, &AdnlPeer::get_stats, all,
+        [id = id, callback](td::Result<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> R) {
+          if (R.is_error()) {
+            VLOG(ADNL_NOTICE) << "failed to get stats for peer " << id << " : " << R.move_as_error();
+            td::actor::send_closure(callback, &Cb::dec_pending);
+          } else {
+            td::actor::send_closure(callback, &Cb::got_peer_stats, R.move_as_ok());
+          }
+        });
+  }
+  td::actor::send_closure(callback, &Cb::dec_pending);
+}
+
 }  // namespace adnl
 
 }  // namespace ton

adnl/adnl-peer-table.h

@@ -90,7 +90,7 @@ class AdnlPeerTable : public Adnl {
   virtual void answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlQueryId query_id, td::BufferSlice data) = 0;
 
   virtual void receive_packet(td::IPAddress addr, AdnlCategoryMask cat_mask, td::BufferSlice data) = 0;
-  virtual void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket packet) = 0;
+  virtual void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket packet, td::uint64 serialized_size) = 0;
   virtual void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message, td::uint32 flags) = 0;
 
   virtual void register_channel(AdnlChannelIdShort id, AdnlNodeIdShort local_id,
@@ -110,6 +110,7 @@ class AdnlPeerTable : public Adnl {
   virtual void deliver_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data,
                              td::Promise<td::BufferSlice> promise) = 0;
   virtual void decrypt_message(AdnlNodeIdShort dst, td::BufferSlice data, td::Promise<td::BufferSlice> promise) = 0;
+  virtual void get_conn_ip_str(AdnlNodeIdShort l_id, AdnlNodeIdShort p_id, td::Promise<td::string> promise) = 0;
 };
 
 }  // namespace adnl

adnl/adnl-peer-table.hpp

@@ -44,7 +44,7 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
   void add_static_nodes_from_config(AdnlNodesList nodes) override;
 
   void receive_packet(td::IPAddress addr, AdnlCategoryMask cat_mask, td::BufferSlice data) override;
-  void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket data) override;
+  void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket data, td::uint64 serialized_size) override;
   void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message, td::uint32 flags) override;
   void send_message(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data) override {
     send_message_ex(src, dst, std::move(data), 0);
@@ -77,6 +77,10 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
                         td::actor::ActorId<AdnlChannel> channel) override;
   void unregister_channel(AdnlChannelIdShort id) override;
 
+  void check_id_exists(AdnlNodeIdShort id, td::Promise<bool> promise) override {
+    promise.set_value(local_ids_.count(id));
+  }
+
   void write_new_addr_list_to_db(AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id, AdnlDbItem node,
                                  td::Promise<td::Unit> promise) override;
   void get_addr_list_from_db(AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id,
@@ -102,6 +106,9 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
 
   void create_tunnel(AdnlNodeIdShort dst, td::uint32 size,
                      td::Promise<std::pair<td::actor::ActorOwn<AdnlTunnel>, AdnlAddress>> promise) override;
+  void get_conn_ip_str(AdnlNodeIdShort l_id, AdnlNodeIdShort p_id, td::Promise<td::string> promise) override;
+
+  void get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats>> promise) override;
 
   struct PrintId {};
   PrintId print_id() const {

adnl/adnl-peer.cpp

@@ -26,6 +26,7 @@
 #include "td/utils/base64.h"
 #include "td/utils/Random.h"
 #include "auto/tl/ton_api.h"
+#include "td/utils/overloaded.h"
 
 namespace ton {
 
@@ -50,9 +51,13 @@ void AdnlPeerPairImpl::start_up() {
 }
 
 void AdnlPeerPairImpl::alarm() {
-  if (next_dht_query_at_ && next_dht_query_at_.is_in_past()) {
-    next_dht_query_at_ = td::Timestamp::never();
-    discover();
+  if (!disable_dht_query_) {
+    disable_dht_query_ = true;
+    if (next_dht_query_at_ && next_dht_query_at_.is_in_past()) {
+      next_dht_query_at_ = td::Timestamp::never();
+      discover();
+    }
+    alarm_timestamp().relax(next_dht_query_at_);
   }
   if (next_db_update_at_ && next_db_update_at_.is_in_past()) {
     if (received_from_db_ && received_from_static_nodes_ && !peer_id_.empty()) {
@@ -68,9 +73,8 @@ void AdnlPeerPairImpl::alarm() {
   }
   if (retry_send_at_ && retry_send_at_.is_in_past()) {
     retry_send_at_ = td::Timestamp::never();
-    send_messages_in(std::move(pending_messages_), false);
+    send_messages_from_queue();
   }
-  alarm_timestamp().relax(next_dht_query_at_);
   alarm_timestamp().relax(next_db_update_at_);
   alarm_timestamp().relax(retry_send_at_);
 }
@@ -113,6 +117,10 @@ void AdnlPeerPairImpl::discover() {
 }
 
 void AdnlPeerPairImpl::receive_packet_checked(AdnlPacket packet) {
+  last_received_packet_ = td::Timestamp::now();
+  try_reinit_at_ = td::Timestamp::never();
+  drop_addr_list_at_ = td::Timestamp::never();
+  request_reverse_ping_after_ = td::Timestamp::in(15.0);
   auto d = Adnl::adnl_start_time();
   if (packet.dst_reinit_date() > d) {
     VLOG(ADNL_WARNING) << this << ": dropping IN message: too new our reinit date " << packet.dst_reinit_date();
@@ -202,16 +210,24 @@ void AdnlPeerPairImpl::receive_packet_checked(AdnlPacket packet) {
   }
 }
 
-void AdnlPeerPairImpl::receive_packet_from_channel(AdnlChannelIdShort id, AdnlPacket packet) {
+void AdnlPeerPairImpl::receive_packet_from_channel(AdnlChannelIdShort id, AdnlPacket packet,
+                                                   td::uint64 serialized_size) {
+  add_packet_stats(serialized_size, /* in = */ true, /* channel = */ true);
   if (id != channel_in_id_) {
     VLOG(ADNL_NOTICE) << this << ": dropping IN message: outdated channel id" << id;
     return;
   }
-  channel_ready_ = true;
+  if (channel_inited_ && !channel_ready_) {
+    channel_ready_ = true;
+    if (!out_messages_queue_.empty()) {
+      td::actor::send_closure(actor_id(this), &AdnlPeerPairImpl::send_messages_from_queue);
+    }
+  }
   receive_packet_checked(std::move(packet));
 }
 
-void AdnlPeerPairImpl::receive_packet(AdnlPacket packet) {
+void AdnlPeerPairImpl::receive_packet(AdnlPacket packet, td::uint64 serialized_size) {
+  add_packet_stats(serialized_size, /* in = */ true, /* channel = */ false);
   packet.run_basic_checks().ensure();
 
   if (!encryptor_) {
@@ -232,126 +248,132 @@ void AdnlPeerPairImpl::deliver_message(AdnlMessage message) {
   message.visit([&](const auto &obj) { this->process_message(obj); });
 }
 
-void AdnlPeerPairImpl::send_messages_in(std::vector<OutboundAdnlMessage> messages, bool allow_postpone) {
-  for (td::int32 idx = 0; idx < 2; idx++) {
-    std::vector<OutboundAdnlMessage> not_sent;
+void AdnlPeerPairImpl::send_messages_from_queue() {
+  while (!out_messages_queue_.empty() && out_messages_queue_.front().second.is_in_past()) {
+    out_messages_queue_total_size_ -= out_messages_queue_.front().first.size();
+    add_expired_msg_stats(out_messages_queue_.front().first.size());
+    out_messages_queue_.pop();
+    VLOG(ADNL_NOTICE) << this << ": dropping OUT message: message in queue expired";
+  }
+  if (out_messages_queue_.empty()) {
+    return;
+  }
 
-    auto connR = get_conn(idx == 1);
-    if (connR.is_error()) {
-      if (!allow_postpone) {
-        VLOG(ADNL_NOTICE) << this << ": dropping OUT messages: cannot get conn: " << connR.move_as_error();
-        return;
-      }
-      VLOG(ADNL_INFO) << this << ": delaying OUT messages: cannot get conn: " << connR.move_as_error();
-      if (!retry_send_at_) {
-        retry_send_at_.relax(td::Timestamp::in(10.0));
-        alarm_timestamp().relax(retry_send_at_);
-      }
-      for (auto &m : messages) {
-        pending_messages_.push_back(std::move(m));
-      }
+  auto connR = get_conn();
+  if (connR.is_error()) {
+    disable_dht_query_ = false;
+    retry_send_at_.relax(td::Timestamp::in(message_in_queue_ttl_ - 1.0));
+    alarm_timestamp().relax(retry_send_at_);
+    VLOG(ADNL_INFO) << this << ": delaying OUT messages: cannot get conn: " << connR.move_as_error();
+    return;
+  }
+  disable_dht_query_ = true;
+  auto C = connR.move_as_ok();
+  auto conn = std::move(C.first);
+  bool is_direct = C.second;
+
+  bool first = !skip_init_packet_;
+  while (!out_messages_queue_.empty()) {
+    bool try_reinit = try_reinit_at_ && try_reinit_at_.is_in_past();
+    bool via_channel = channel_ready_ && !try_reinit;
+    if (!via_channel && !nochannel_rate_limiter_.take()) {
+      alarm_timestamp().relax(retry_send_at_ = nochannel_rate_limiter_.ready_at());
       return;
     }
-    auto C = connR.move_as_ok();
-    bool is_direct = C.second;
-    auto conn = std::move(C.first);
-    if (idx == 1) {
-      CHECK(is_direct);
+    if (try_reinit) {
+      try_reinit_at_ = td::Timestamp::in(td::Random::fast(0.5, 1.5));
+    }
+    respond_with_nop_after_ = td::Timestamp::in(td::Random::fast(1.0, 2.0));
+
+    size_t s = (via_channel ? channel_packet_header_max_size() : packet_header_max_size());
+    if (first) {
+      s += 2 * addr_list_max_size();
     }
 
-    size_t ptr = 0;
-    bool first = true;
-    do {
-      size_t s = (channel_ready_ ? channel_packet_header_max_size() : packet_header_max_size());
-      if (first) {
-        s += 2 * addr_list_max_size();
-      }
+    AdnlPacket packet;
+    packet.set_seqno(++out_seqno_);
+    packet.set_confirm_seqno(in_seqno_);
 
-      AdnlPacket packet;
-      packet.set_seqno(++out_seqno_);
-      packet.set_confirm_seqno(in_seqno_);
-
-      if (first) {
-        if (!channel_inited_) {
-          auto M = adnlmessage::AdnlMessageCreateChannel{channel_pub_, channel_pk_date_};
-          s += M.size();
-          packet.add_message(std::move(M));
-        } else if (!channel_ready_) {
-          auto M = adnlmessage::AdnlMessageConfirmChannel{channel_pub_, peer_channel_pub_, channel_pk_date_};
-          s += M.size();
-          packet.add_message(std::move(M));
-        }
+    if (first) {
+      if (!channel_inited_) {
+        auto M = adnlmessage::AdnlMessageCreateChannel{channel_pub_, channel_pk_date_};
+        s += M.size();
+        packet.add_message(std::move(M));
+      } else if (!channel_ready_) {
+        auto M = adnlmessage::AdnlMessageConfirmChannel{channel_pub_, peer_channel_pub_, channel_pk_date_};
+        s += M.size();
+        packet.add_message(std::move(M));
       }
+    }
 
-      if (!addr_list_.empty()) {
-        packet.set_received_addr_list_version(addr_list_.version());
-      }
-      if (!priority_addr_list_.empty()) {
-        packet.set_received_priority_addr_list_version(priority_addr_list_.version());
-      }
+    if (!addr_list_.empty()) {
+      packet.set_received_addr_list_version(addr_list_.version());
+    }
+    if (!priority_addr_list_.empty()) {
+      packet.set_received_priority_addr_list_version(priority_addr_list_.version());
+    }
 
-      while (ptr < messages.size()) {
-        auto &M = messages[ptr];
-        if (!is_direct && (M.flags() & Adnl::SendFlags::direct_only)) {
-          not_sent.push_back(std::move(M));
-          continue;
-        }
-        CHECK(M.size() <= get_mtu());
+    skip_init_packet_ = true;
+    while (!out_messages_queue_.empty()) {
+      auto &M = out_messages_queue_.front().first;
+      if (!is_direct && (M.flags() & Adnl::SendFlags::direct_only)) {
+        out_messages_queue_total_size_ -= M.size();
+        out_messages_queue_.pop();
+        continue;
+      }
+      CHECK(M.size() <= get_mtu());
+      if (s + M.size() <= AdnlNetworkManager::get_mtu()) {
+        s += M.size();
+        out_messages_queue_total_size_ -= M.size();
+        packet.add_message(M.release());
+        out_messages_queue_.pop();
+        skip_init_packet_ = false;
+      } else {
+        break;
+      }
+    }
+
+    if (!via_channel) {
+      packet.set_reinit_date(Adnl::adnl_start_time(), reinit_date_);
+      packet.set_source(local_id_);
+    }
+
+    if (!first) {
+      if (!channel_inited_) {
+        auto M = adnlmessage::AdnlMessageCreateChannel{channel_pub_, channel_pk_date_};
         if (s + M.size() <= AdnlNetworkManager::get_mtu()) {
           s += M.size();
-          packet.add_message(M.release());
-          ptr++;
-        } else {
-          break;
+          packet.add_message(std::move(M));
+        }
+      } else if (!channel_ready_) {
+        auto M = adnlmessage::AdnlMessageConfirmChannel{channel_pub_, peer_channel_pub_, channel_pk_date_};
+        if (s + M.size() <= AdnlNetworkManager::get_mtu()) {
+          s += M.size();
+          packet.add_message(std::move(M));
         }
       }
-
-      if (!channel_ready_) {
-        packet.set_reinit_date(Adnl::adnl_start_time(), reinit_date_);
-        packet.set_source(local_id_);
-      }
-
-      if (!first) {
-        if (!channel_inited_) {
-          auto M = adnlmessage::AdnlMessageCreateChannel{channel_pub_, channel_pk_date_};
-          if (s + M.size() <= AdnlNetworkManager::get_mtu()) {
-            s += M.size();
-            packet.add_message(std::move(M));
-          }
-        } else if (!channel_ready_) {
-          auto M = adnlmessage::AdnlMessageConfirmChannel{channel_pub_, peer_channel_pub_, channel_pk_date_};
-          if (s + M.size() <= AdnlNetworkManager::get_mtu()) {
-            s += M.size();
-            packet.add_message(std::move(M));
-          }
-        }
-      }
-
-      packet.run_basic_checks().ensure();
-      auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), conn, id = print_id(),
-                                           via_channel = channel_ready_](td::Result<AdnlPacket> res) {
-        if (res.is_error()) {
-          LOG(ERROR) << id << ": dropping OUT message: error while creating packet: " << res.move_as_error();
-        } else {
-          td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_packet_continue, res.move_as_ok(), conn, via_channel);
-        }
-      });
-
-      td::actor::send_closure(local_actor_, &AdnlLocalId::update_packet, std::move(packet),
-                              !channel_ready_ && ack_seqno_ == 0 && in_seqno_ == 0, !channel_ready_,
-                              (first || s + addr_list_max_size() <= AdnlNetworkManager::get_mtu())
-                                  ? peer_recv_addr_list_version_
-                                  : 0x7fffffff,
-                              (first || s + 2 * addr_list_max_size() <= AdnlNetworkManager::get_mtu())
-                                  ? peer_recv_priority_addr_list_version_
-                                  : 0x7fffffff,
-                              std::move(P));
-      first = false;
-    } while (ptr < messages.size());
-    messages = std::move(not_sent);
-    if (!messages.size()) {
-      break;
     }
+
+    packet.run_basic_checks().ensure();
+    auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), conn, id = print_id(),
+                                         via_channel](td::Result<AdnlPacket> res) {
+      if (res.is_error()) {
+        LOG(ERROR) << id << ": dropping OUT message: error while creating packet: " << res.move_as_error();
+      } else {
+        td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_packet_continue, res.move_as_ok(), conn, via_channel);
+      }
+    });
+
+    td::actor::send_closure(local_actor_, &AdnlLocalId::update_packet, std::move(packet),
+                            (!channel_ready_ && ack_seqno_ == 0 && in_seqno_ == 0) || try_reinit, !via_channel,
+                            (first || s + addr_list_max_size() <= AdnlNetworkManager::get_mtu())
+                                ? (try_reinit ? 0 : peer_recv_addr_list_version_)
+                                : 0x7fffffff,
+                            (first || s + 2 * addr_list_max_size() <= AdnlNetworkManager::get_mtu())
+                                ? peer_recv_priority_addr_list_version_
+                                : 0x7fffffff,
+                            std::move(P));
+    first = false;
   }
 }
 
@@ -382,15 +404,26 @@ void AdnlPeerPairImpl::send_messages(std::vector<OutboundAdnlMessage> messages)
       }
     }
   }
-  send_messages_in(std::move(new_vec), true);
+  for (auto &m : new_vec) {
+    out_messages_queue_total_size_ += m.size();
+    out_messages_queue_.emplace(std::move(m), td::Timestamp::in(message_in_queue_ttl_));
+  }
+  send_messages_from_queue();
 }
 
 void AdnlPeerPairImpl::send_packet_continue(AdnlPacket packet, td::actor::ActorId<AdnlNetworkConnection> conn,
                                             bool via_channel) {
+  if (!try_reinit_at_ && last_received_packet_ < td::Timestamp::in(-5.0)) {
+    try_reinit_at_ = td::Timestamp::in(10.0);
+  }
+  if (!drop_addr_list_at_ && last_received_packet_ < td::Timestamp::in(-60.0 * 9.0)) {
+    drop_addr_list_at_ = td::Timestamp::in(60.0);
+  }
   packet.run_basic_checks().ensure();
   auto B = serialize_tl_object(packet.tl(), true);
   if (via_channel) {
     if (channel_ready_) {
+      add_packet_stats(B.size(), /* in = */ false, /* channel = */ true);
       td::actor::send_closure(channel_, &AdnlChannel::send_message, priority_, conn, std::move(B));
     } else {
       VLOG(ADNL_WARNING) << this << ": dropping OUT message [" << local_id_ << "->" << peer_id_short_
@@ -418,6 +451,7 @@ void AdnlPeerPairImpl::send_packet_continue(AdnlPacket packet, td::actor::ActorI
   S.remove_prefix(32);
   S.copy_from(X.as_slice());
 
+  add_packet_stats(B.size(), /* in = */ false, /* channel = */ false);
   td::actor::send_closure(conn, &AdnlNetworkConnection::send, local_id_, peer_id_short_, priority_, std::move(enc));
 }
 
@@ -504,10 +538,14 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageConfirmChan
     VLOG(ADNL_NOTICE) << this << ": received adnl.message.confirmChannel with old key";
     return;
   }
-  channel_ready_ = true;
+  if (!channel_ready_) {
+    channel_ready_ = true;
+    send_messages_from_queue();
+  }
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageCustom &message) {
+  respond_with_nop();
   td::actor::send_closure(local_actor_, &AdnlLocalId::deliver, peer_id_short_, message.data());
 }
 
@@ -520,6 +558,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageReinit &mes
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &message) {
+  respond_with_nop();
   auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), query_id = message.query_id(),
                                        flags = static_cast<td::uint32>(0)](td::Result<td::BufferSlice> R) {
     if (R.is_error()) {
@@ -538,6 +577,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &mess
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageAnswer &message) {
+  respond_with_nop();
   auto Q = out_queries_.find(message.query_id());
 
   if (Q == out_queries_.end()) {
@@ -555,6 +595,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageAnswer &mes
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessagePart &message) {
+  respond_with_nop();
   auto size = message.total_size();
   if (size > huge_packet_max_size()) {
     VLOG(ADNL_WARNING) << this << ": dropping too big huge message: size=" << size;
@@ -617,6 +658,14 @@ void AdnlPeerPairImpl::delete_query(AdnlQueryId id) {
   }
 }
 
+void AdnlPeerPairImpl::respond_with_nop() {
+  if (respond_with_nop_after_.is_in_past()) {
+    std::vector<OutboundAdnlMessage> messages;
+    messages.emplace_back(adnlmessage::AdnlMessageNop{}, 0);
+    send_messages(std::move(messages));
+  }
+}
+
 void AdnlPeerPairImpl::reinit(td::int32 date) {
   if (reinit_date_ == 0) {
     reinit_date_ = date;
@@ -646,27 +695,46 @@ void AdnlPeerPairImpl::reinit(td::int32 date) {
   }
 }
 
-td::Result<std::pair<td::actor::ActorId<AdnlNetworkConnection>, bool>> AdnlPeerPairImpl::get_conn(bool direct_only) {
+td::Result<std::pair<td::actor::ActorId<AdnlNetworkConnection>, bool>> AdnlPeerPairImpl::get_conn() {
+  if (drop_addr_list_at_ && drop_addr_list_at_.is_in_past()) {
+    drop_addr_list_at_ = td::Timestamp::never();
+    priority_addr_list_ = AdnlAddressList{};
+    priority_conns_.clear();
+    addr_list_ = AdnlAddressList{};
+    conns_.clear();
+    has_reverse_addr_ = false;
+    return td::Status::Error(ErrorCode::notready, "no active connections");
+  }
+
   if (!priority_addr_list_.empty() && priority_addr_list_.expire_at() < td::Clocks::system()) {
     priority_addr_list_ = AdnlAddressList{};
     priority_conns_.clear();
   }
 
   if (conns_.size() == 0 && priority_conns_.size() == 0) {
-    return td::Status::Error(ErrorCode::notready, PSTRING()
-                                                      << "empty network information: version=" << addr_list_.version()
-                                                      << " reinit_date=" << addr_list_.reinit_date()
-                                                      << " real_reinit_date=" << reinit_date_);
-  }
-
-  for (auto &conn : priority_conns_) {
-    if (conn.ready() && (!direct_only || conn.is_direct())) {
-      return std::make_pair(conn.conn.get(), conn.is_direct());
+    if (has_reverse_addr_) {
+      request_reverse_ping();
+      return td::Status::Error(ErrorCode::notready, "waiting for reverse ping");
+    } else {
+      return td::Status::Error(ErrorCode::notready, PSTRING()
+                                                        << "empty network information: version=" << addr_list_.version()
+                                                        << " reinit_date=" << addr_list_.reinit_date()
+                                                        << " real_reinit_date=" << reinit_date_);
     }
   }
-  for (auto &conn : conns_) {
-    if (conn.ready() && (!direct_only || conn.is_direct())) {
-      return std::make_pair(conn.conn.get(), conn.is_direct());
+
+  for (int direct_only = 1; direct_only >= 0; --direct_only) {
+    for (auto &conn : priority_conns_) {
+      if (conn.ready() && (!direct_only || conn.is_direct())) {
+        return std::make_pair(conn.conn.get(), conn.is_direct());
+      }
+    }
+  }
+  for (int direct_only = 1; direct_only >= 0; --direct_only) {
+    for (auto &conn : conns_) {
+      if (conn.ready() && (!direct_only || conn.is_direct())) {
+        return std::make_pair(conn.conn.get(), conn.is_direct());
+      }
     }
   }
   return td::Status::Error(ErrorCode::notready, "no active connections");
@@ -704,11 +772,18 @@ void AdnlPeerPairImpl::update_addr_list(AdnlAddressList addr_list) {
   VLOG(ADNL_INFO) << this << ": updating addr list to version " << addr_list.version() << " size=" << addr_list.size();
 
   const auto addrs = addr_list.addrs();
+  has_reverse_addr_ = addr_list.has_reverse();
+  if (has_reverse_addr_ && addrs.empty()) {
+    return;
+  }
   std::vector<Conn> conns;
   auto &old_conns = priority ? priority_conns_ : conns_;
 
   size_t idx = 0;
   for (const auto &addr : addrs) {
+    if (addr->is_reverse()) {
+      continue;
+    }
     if ((mode_ & static_cast<td::uint32>(AdnlLocalIdMode::direct_only)) && !addr->is_public()) {
       continue;
     }
@@ -725,6 +800,77 @@ void AdnlPeerPairImpl::update_addr_list(AdnlAddressList addr_list) {
   (priority ? priority_addr_list_ : addr_list_) = addr_list;
 }
 
+void AdnlPeerPairImpl::get_conn_ip_str(td::Promise<td::string> promise) {
+  if (conns_.size() == 0 && priority_conns_.size() == 0) {
+    promise.set_value("undefined");
+    return;
+  }
+
+  for (auto &conn : priority_conns_) {
+    if (conn.ready()) {
+      td::actor::send_closure(conn.conn, &AdnlNetworkConnection::get_ip_str, std::move(promise));
+      return;
+    }
+  }
+  for (auto &conn : conns_) {
+    if (conn.ready()) {
+      td::actor::send_closure(conn.conn, &AdnlNetworkConnection::get_ip_str, std::move(promise));
+      return;
+    }
+  }
+
+  promise.set_value("undefined");
+}
+
+void AdnlPeerPairImpl::get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats_peerPair>> promise) {
+  if (!all) {
+    double threshold = td::Clocks::system() - 600.0;
+    if (last_in_packet_ts_ < threshold && last_out_packet_ts_ < threshold) {
+      promise.set_value(nullptr);
+      return;
+    }
+  }
+
+  auto stats = create_tl_object<ton_api::adnl_stats_peerPair>();
+  stats->local_id_ = local_id_.bits256_value();
+  stats->peer_id_ = peer_id_short_.bits256_value();
+  for (const AdnlAddress &addr : addr_list_.addrs()) {
+    ton_api::downcast_call(*addr->tl(), td::overloaded(
+                                            [&](const ton_api::adnl_address_udp &obj) {
+                                              stats->ip_str_ = PSTRING() << td::IPAddress::ipv4_to_str(obj.ip_) << ":"
+                                                                         << obj.port_;
+                                            },
+                                            [&](const auto &) {}));
+    if (!stats->ip_str_.empty()) {
+      break;
+    }
+  }
+
+  prepare_packet_stats();
+  stats->last_in_packet_ts_ = last_in_packet_ts_;
+  stats->last_out_packet_ts_ = last_out_packet_ts_;
+  stats->packets_total_ = packet_stats_total_.tl();
+  stats->packets_total_->ts_start_ = started_ts_;
+  stats->packets_total_->ts_end_ = td::Clocks::system();
+  stats->packets_recent_ = packet_stats_prev_.tl();
+
+  if (channel_ready_) {
+    stats->channel_status_ = 2;
+  } else if (channel_inited_) {
+    stats->channel_status_ = 1;
+  } else {
+    stats->channel_status_ = 0;
+  }
+  stats->try_reinit_at_ = (try_reinit_at_ ? try_reinit_at_.at_unix() : 0.0);
+  stats->connection_ready_ =
+      std::any_of(conns_.begin(), conns_.end(), [](const Conn &conn) { return conn.ready(); }) ||
+      std::any_of(priority_conns_.begin(), priority_conns_.end(), [](const Conn &conn) { return conn.ready(); });
+  stats->out_queue_messages_ = out_messages_queue_.size();
+  stats->out_queue_bytes_ = out_messages_queue_total_size_;
+
+  promise.set_result(std::move(stats));
+}
+
 void AdnlPeerImpl::update_id(AdnlNodeIdFull id) {
   CHECK(id.compute_short_id() == peer_id_short_);
   if (!peer_id_.empty()) {
@@ -748,8 +894,8 @@ void AdnlPeerPairImpl::Conn::create_conn(td::actor::ActorId<AdnlPeerPairImpl> pe
 
 void AdnlPeerPairImpl::conn_change_state(AdnlConnectionIdShort id, bool ready) {
   if (ready) {
-    if (pending_messages_.size() > 0) {
-      send_messages_in(std::move(pending_messages_), true);
+    if (out_messages_queue_.empty()) {
+      send_messages_from_queue();
     }
   }
 }
@@ -771,7 +917,7 @@ td::actor::ActorOwn<AdnlPeer> AdnlPeer::create(td::actor::ActorId<AdnlNetworkMan
 }
 
 void AdnlPeerImpl::receive_packet(AdnlNodeIdShort dst, td::uint32 dst_mode, td::actor::ActorId<AdnlLocalId> dst_actor,
-                                  AdnlPacket packet) {
+                                  AdnlPacket packet, td::uint64 serialized_size) {
   if (packet.inited_from()) {
     update_id(packet.from());
   }
@@ -789,7 +935,7 @@ void AdnlPeerImpl::receive_packet(AdnlNodeIdShort dst, td::uint32 dst_mode, td::
     }
   }
 
-  td::actor::send_closure(it->second.get(), &AdnlPeerPair::receive_packet_checked, std::move(packet));
+  td::actor::send_closure(it->second.get(), &AdnlPeerPair::receive_packet, std::move(packet), serialized_size);
 }
 
 void AdnlPeerImpl::send_messages(AdnlNodeIdShort src, td::uint32 src_mode, td::actor::ActorId<AdnlLocalId> src_actor,
@@ -841,6 +987,16 @@ void AdnlPeerImpl::update_dht_node(td::actor::ActorId<dht::Dht> dht_node) {
   }
 }
 
+void AdnlPeerImpl::get_conn_ip_str(AdnlNodeIdShort l_id, td::Promise<td::string> promise) {
+  auto it = peer_pairs_.find(l_id);
+  if (it == peer_pairs_.end()) {
+    promise.set_value("undefined");
+    return;
+  }
+
+  td::actor::send_closure(it->second, &AdnlPeerPair::get_conn_ip_str, std::move(promise));
+}
+
 void AdnlPeerImpl::update_addr_list(AdnlNodeIdShort local_id, td::uint32 local_mode,
                                     td::actor::ActorId<AdnlLocalId> local_actor, AdnlAddressList addr_list) {
   auto it = peer_pairs_.find(local_id);
@@ -859,6 +1015,58 @@ void AdnlPeerImpl::update_addr_list(AdnlNodeIdShort local_id, td::uint32 local_m
   td::actor::send_closure(it->second, &AdnlPeerPair::update_addr_list, std::move(addr_list));
 }
 
+void AdnlPeerImpl::get_stats(bool all, td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise) {
+  class Cb : public td::actor::Actor {
+   public:
+    explicit Cb(td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise)
+        : promise_(std::move(promise)) {
+    }
+
+    void got_peer_pair_stats(tl_object_ptr<ton_api::adnl_stats_peerPair> peer_pair) {
+      if (peer_pair) {
+        result_.push_back(std::move(peer_pair));
+      }
+      dec_pending();
+    }
+
+    void inc_pending() {
+      ++pending_;
+    }
+
+    void dec_pending() {
+      CHECK(pending_ > 0);
+      --pending_;
+      if (pending_ == 0) {
+        promise_.set_result(std::move(result_));
+        stop();
+      }
+    }
+
+   private:
+    td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise_;
+    size_t pending_ = 1;
+    std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>> result_;
+  };
+  auto callback = td::actor::create_actor<Cb>("adnlpeerstats", std::move(promise)).release();
+
+  for (auto &[local_id, peer_pair] : peer_pairs_) {
+    td::actor::send_closure(callback, &Cb::inc_pending);
+    td::actor::send_closure(peer_pair, &AdnlPeerPair::get_stats, all,
+                            [local_id = local_id, peer_id = peer_id_short_,
+                             callback](td::Result<tl_object_ptr<ton_api::adnl_stats_peerPair>> R) {
+                              if (R.is_error()) {
+                                VLOG(ADNL_NOTICE) << "failed to get stats for peer pair " << peer_id << "->" << local_id
+                                                  << " : " << R.move_as_error();
+                                td::actor::send_closure(callback, &Cb::dec_pending);
+                              } else {
+                                td::actor::send_closure(callback, &Cb::got_peer_pair_stats, R.move_as_ok());
+                              }
+                            });
+  }
+  td::actor::send_closure(callback, &Cb::dec_pending);
+}
+
+
 void AdnlPeerPairImpl::got_data_from_db(td::Result<AdnlDbItem> R) {
   received_from_db_ = false;
   if (R.is_error()) {
@@ -912,6 +1120,96 @@ void AdnlPeerPairImpl::update_peer_id(AdnlNodeIdFull id) {
   CHECK(!peer_id_.empty());
 }
 
+void AdnlPeerPairImpl::request_reverse_ping() {
+  if (request_reverse_ping_active_ || !request_reverse_ping_after_.is_in_past()) {
+    return;
+  }
+  VLOG(ADNL_INFO) << this << ": requesting reverse ping";
+  request_reverse_ping_after_ = td::Timestamp::in(15.0);
+  request_reverse_ping_active_ = true;
+  td::actor::send_closure(
+      local_actor_, &AdnlLocalId::get_self_node,
+      [SelfId = actor_id(this), peer = peer_id_short_, dht = dht_node_](td::Result<AdnlNode> R) {
+        if (R.is_error()) {
+          td::actor::send_closure(SelfId, &AdnlPeerPairImpl::request_reverse_ping_result, R.move_as_error());
+          return;
+        }
+        td::actor::send_closure(
+            dht, &dht::Dht::request_reverse_ping, R.move_as_ok(), peer, [SelfId](td::Result<td::Unit> R) {
+              td::actor::send_closure(SelfId, &AdnlPeerPairImpl::request_reverse_ping_result, std::move(R));
+            });
+      });
+}
+
+void AdnlPeerPairImpl::request_reverse_ping_result(td::Result<td::Unit> R) {
+  request_reverse_ping_active_ = false;
+  if (R.is_ok()) {
+    VLOG(ADNL_INFO) << this << ": reverse ping requested";
+  } else {
+    VLOG(ADNL_INFO) << this << ": failed to request reverse ping: " << R.move_as_error();
+  }
+}
+
+void AdnlPeerPairImpl::add_packet_stats(td::uint64 bytes, bool in, bool channel) {
+  prepare_packet_stats();
+  auto add_stats = [&](PacketStats &stats) {
+    if (in) {
+      ++stats.in_packets;
+      stats.in_bytes += bytes;
+      if (channel) {
+        ++stats.in_packets_channel;
+        stats.in_bytes_channel += bytes;
+      }
+    } else {
+      ++stats.out_packets;
+      stats.out_bytes += bytes;
+      if (channel) {
+        ++stats.out_packets_channel;
+        stats.out_bytes_channel += bytes;
+      }
+    }
+  };
+  add_stats(packet_stats_cur_);
+  add_stats(packet_stats_total_);
+  if (in) {
+    last_in_packet_ts_ = td::Clocks::system();
+  } else {
+    last_out_packet_ts_ = td::Clocks::system();
+  }
+}
+
+void AdnlPeerPairImpl::add_expired_msg_stats(td::uint64 bytes) {
+  prepare_packet_stats();
+  auto add_stats = [&](PacketStats &stats) {
+    ++stats.out_expired_messages;
+    stats.out_expired_bytes += bytes;
+  };
+  add_stats(packet_stats_cur_);
+  add_stats(packet_stats_total_);
+}
+
+void AdnlPeerPairImpl::prepare_packet_stats() {
+  double now = td::Clocks::system();
+  if (now >= packet_stats_cur_.ts_end) {
+    packet_stats_prev_ = std::move(packet_stats_cur_);
+    packet_stats_cur_ = {};
+    auto now_int = (int)now;
+    packet_stats_cur_.ts_start = (double)(now_int / 60 * 60);
+    packet_stats_cur_.ts_end = packet_stats_cur_.ts_start + 60.0;
+    if (packet_stats_prev_.ts_end < now - 60.0) {
+      packet_stats_prev_ = {};
+      packet_stats_prev_.ts_end = packet_stats_cur_.ts_start;
+      packet_stats_prev_.ts_start = packet_stats_prev_.ts_end - 60.0;
+    }
+  }
+}
+
+tl_object_ptr<ton_api::adnl_stats_packets> AdnlPeerPairImpl::PacketStats::tl() const {
+  return create_tl_object<ton_api::adnl_stats_packets>(ts_start, ts_end, in_packets, in_bytes, in_packets_channel,
+                                                       in_bytes_channel, out_packets, out_bytes, out_packets_channel,
+                                                       out_bytes_channel, out_expired_messages, out_expired_bytes);
+}
+
 }  // namespace adnl
 
 }  // namespace ton

adnl/adnl-peer.h

@@ -39,9 +39,9 @@ class AdnlPeer;
 
 class AdnlPeerPair : public td::actor::Actor {
  public:
-  virtual void receive_packet_from_channel(AdnlChannelIdShort id, AdnlPacket packet) = 0;
+  virtual void receive_packet_from_channel(AdnlChannelIdShort id, AdnlPacket packet, td::uint64 serialized_size) = 0;
   virtual void receive_packet_checked(AdnlPacket packet) = 0;
-  virtual void receive_packet(AdnlPacket packet) = 0;
+  virtual void receive_packet(AdnlPacket packet, td::uint64 serialized_size) = 0;
 
   virtual void send_messages(std::vector<OutboundAdnlMessage> message) = 0;
   inline void send_message(OutboundAdnlMessage message) {
@@ -58,6 +58,8 @@ class AdnlPeerPair : public td::actor::Actor {
   virtual void update_dht_node(td::actor::ActorId<dht::Dht> dht_node) = 0;
   virtual void update_peer_id(AdnlNodeIdFull id) = 0;
   virtual void update_addr_list(AdnlAddressList addr_list) = 0;
+  virtual void get_conn_ip_str(td::Promise<td::string> promise) = 0;
+  virtual void get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats_peerPair>> promise) = 0;
 
   static td::actor::ActorOwn<AdnlPeerPair> create(td::actor::ActorId<AdnlNetworkManager> network_manager,
                                                   td::actor::ActorId<AdnlPeerTable> peer_table, td::uint32 local_mode,
@@ -70,7 +72,7 @@ class AdnlPeerPair : public td::actor::Actor {
 class AdnlPeer : public td::actor::Actor {
  public:
   virtual void receive_packet(AdnlNodeIdShort dst, td::uint32 dst_mode, td::actor::ActorId<AdnlLocalId> dst_actor,
-                              AdnlPacket message) = 0;
+                              AdnlPacket message, td::uint64 serialized_size) = 0;
   virtual void send_messages(AdnlNodeIdShort src, td::uint32 src_mode, td::actor::ActorId<AdnlLocalId> src_actor,
                              std::vector<OutboundAdnlMessage> messages) = 0;
   virtual void send_query(AdnlNodeIdShort src, td::uint32 src_mode, td::actor::ActorId<AdnlLocalId> src_actor,
@@ -98,6 +100,8 @@ class AdnlPeer : public td::actor::Actor {
   virtual void update_addr_list(AdnlNodeIdShort local_id, td::uint32 local_mode,
                                 td::actor::ActorId<AdnlLocalId> local_actor, AdnlAddressList addr_list) = 0;
   virtual void update_dht_node(td::actor::ActorId<dht::Dht> dht_node) = 0;
+  virtual void get_conn_ip_str(AdnlNodeIdShort l_id, td::Promise<td::string> promise) = 0;
+  virtual void get_stats(bool all, td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise) = 0;
 };
 
 }  // namespace adnl

adnl/adnl-peer.hpp

@@ -20,6 +20,7 @@
 
 #include <vector>
 #include <map>
+#include <queue>
 
 #include "adnl-peer.h"
 #include "adnl-peer-table.h"
@@ -66,12 +67,12 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
 
   void discover();
 
-  void receive_packet_from_channel(AdnlChannelIdShort id, AdnlPacket packet) override;
+  void receive_packet_from_channel(AdnlChannelIdShort id, AdnlPacket packet, td::uint64 serialized_size) override;
   void receive_packet_checked(AdnlPacket packet) override;
-  void receive_packet(AdnlPacket packet) override;
+  void receive_packet(AdnlPacket packet, td::uint64 serialized_size) override;
   void deliver_message(AdnlMessage message);
 
-  void send_messages_in(std::vector<OutboundAdnlMessage> messages, bool allow_postpone);
+  void send_messages_from_queue();
   void send_messages(std::vector<OutboundAdnlMessage> messages) override;
   void send_packet_continue(AdnlPacket packet, td::actor::ActorId<AdnlNetworkConnection> conn, bool via_channel);
   void send_query(std::string name, td::Promise<td::BufferSlice> promise, td::Timestamp timeout, td::BufferSlice data,
@@ -88,6 +89,9 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
   void update_addr_list(AdnlAddressList addr_list) override;
   void update_peer_id(AdnlNodeIdFull id) override;
 
+  void get_conn_ip_str(td::Promise<td::string> promise) override;
+  void get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats_peerPair>> promise) override;
+
   void got_data_from_db(td::Result<AdnlDbItem> R);
   void got_data_from_static_nodes(td::Result<AdnlNode> R);
   void got_data_from_dht(td::Result<AdnlNode> R);
@@ -120,8 +124,9 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
   }
 
  private:
+  void respond_with_nop();
   void reinit(td::int32 date);
-  td::Result<std::pair<td::actor::ActorId<AdnlNetworkConnection>, bool>> get_conn(bool direct_only);
+  td::Result<std::pair<td::actor::ActorId<AdnlNetworkConnection>, bool>> get_conn();
   void create_channel(pubkeys::Ed25519 pub, td::uint32 date);
 
   bool received_packet(td::uint64 seqno) const {
@@ -151,6 +156,9 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
     }
   }
 
+  void request_reverse_ping();
+  void request_reverse_ping_result(td::Result<td::Unit> R);
+
   struct Conn {
     class ConnCallback : public AdnlNetworkConnection::Callback {
      public:
@@ -177,11 +185,11 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
     Conn() {
     }
 
-    bool ready() {
+    bool ready() const {
       return !conn.empty() && conn.get_actor_unsafe().is_active();
     }
 
-    bool is_direct() {
+    bool is_direct() const {
       return addr->is_public();
     }
 
@@ -189,7 +197,14 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
                      td::actor::ActorId<Adnl> adnl);
   };
 
-  std::vector<OutboundAdnlMessage> pending_messages_;
+  // Messages waiting for connection or for nochannel rate limiter
+  std::queue<std::pair<OutboundAdnlMessage, td::Timestamp>> out_messages_queue_;
+  td::uint64 out_messages_queue_total_size_ = 0;
+  RateLimiter nochannel_rate_limiter_ = RateLimiter(50, 0.5);  // max 50, period = 0.5s
+  td::Timestamp retry_send_at_ = td::Timestamp::never();
+  bool disable_dht_query_ = false;
+  bool skip_init_packet_ = false;
+  double message_in_queue_ttl_ = 10.0;
 
   td::actor::ActorId<AdnlNetworkManager> network_manager_;
   td::actor::ActorId<AdnlPeerTable> peer_table_;
@@ -209,6 +224,7 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
   pubkeys::Ed25519 channel_pub_;
   td::int32 channel_pk_date_;
   td::actor::ActorOwn<AdnlChannel> channel_;
+  td::Timestamp respond_with_nop_after_;
 
   td::uint64 in_seqno_ = 0;
   td::uint64 out_seqno_ = 0;
@@ -247,13 +263,34 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
 
   td::Timestamp next_dht_query_at_ = td::Timestamp::never();
   td::Timestamp next_db_update_at_ = td::Timestamp::never();
-  td::Timestamp retry_send_at_ = td::Timestamp::never();
+
+  td::Timestamp last_received_packet_ = td::Timestamp::never();
+  td::Timestamp try_reinit_at_ = td::Timestamp::never();
+  td::Timestamp drop_addr_list_at_ = td::Timestamp::never();
+
+  bool has_reverse_addr_ = false;
+  td::Timestamp request_reverse_ping_after_ = td::Timestamp::now();
+  bool request_reverse_ping_active_ = false;
+
+  struct PacketStats {
+    double ts_start = 0.0, ts_end = 0.0;
+    td::uint64 in_packets = 0, in_bytes = 0, in_packets_channel = 0, in_bytes_channel = 0;
+    td::uint64 out_packets = 0, out_bytes = 0, out_packets_channel = 0, out_bytes_channel = 0;
+    td::uint64 out_expired_messages = 0, out_expired_bytes = 0;
+
+    tl_object_ptr<ton_api::adnl_stats_packets> tl() const;
+  } packet_stats_cur_, packet_stats_prev_, packet_stats_total_;
+  double last_in_packet_ts_ = 0.0, last_out_packet_ts_ = 0.0;
+  double started_ts_ = td::Clocks::system();
+  void add_packet_stats(td::uint64 bytes, bool in, bool channel);
+  void add_expired_msg_stats(td::uint64 bytes);
+  void prepare_packet_stats();
 };
 
 class AdnlPeerImpl : public AdnlPeer {
  public:
   void receive_packet(AdnlNodeIdShort dst, td::uint32 dst_mode, td::actor::ActorId<AdnlLocalId> dst_actor,
-                      AdnlPacket packet) override;
+                      AdnlPacket packet, td::uint64 serialized_size) override;
   void send_messages(AdnlNodeIdShort src, td::uint32 src_mode, td::actor::ActorId<AdnlLocalId> src_actor,
                      std::vector<OutboundAdnlMessage> messages) override;
   void send_query(AdnlNodeIdShort src, td::uint32 src_mode, td::actor::ActorId<AdnlLocalId> src_actor, std::string name,
@@ -265,6 +302,8 @@ class AdnlPeerImpl : public AdnlPeer {
   void update_addr_list(AdnlNodeIdShort local_id, td::uint32 local_mode, td::actor::ActorId<AdnlLocalId> local_actor,
                         AdnlAddressList addr_list) override;
   void update_dht_node(td::actor::ActorId<dht::Dht> dht_node) override;
+  void get_conn_ip_str(AdnlNodeIdShort l_id, td::Promise<td::string> promise) override;
+  void get_stats(bool all, td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise) override;
   //void check_signature(td::BufferSlice data, td::BufferSlice signature, td::Promise<td::Unit> promise) override;
 
   AdnlPeerImpl(td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<AdnlPeerTable> peer_table,

adnl/adnl-pong.cpp

@@ -1,4 +1,4 @@
-/* 
+/*
     This file is part of TON Blockchain source code.
 
     TON Blockchain is free software; you can redistribute it and/or
@@ -14,13 +14,13 @@
     You should have received a copy of the GNU General Public License
     along with TON Blockchain.  If not, see <http://www.gnu.org/licenses/>.
 
-    In addition, as a special exception, the copyright holders give permission 
-    to link the code of portions of this program with the OpenSSL library. 
-    You must obey the GNU General Public License in all respects for all 
-    of the code used other than OpenSSL. If you modify file(s) with this 
-    exception, you may extend this exception to your version of the file(s), 
-    but you are not obligated to do so. If you do not wish to do so, delete this 
-    exception statement from your version. If you delete this exception statement 
+    In addition, as a special exception, the copyright holders give permission
+    to link the code of portions of this program with the OpenSSL library.
+    You must obey the GNU General Public License in all respects for all
+    of the code used other than OpenSSL. If you modify file(s) with this
+    exception, you may extend this exception to your version of the file(s),
+    but you are not obligated to do so. If you do not wish to do so, delete this
+    exception statement from your version. If you delete this exception statement
     from all source files in the program, then also delete it here.
 
     Copyright 2017-2020 Telegram Systems LLP
@@ -41,6 +41,7 @@
 #include "auto/tl/ton_api_json.h"
 #include "adnl/adnl.h"
 #include <map>
+#include "git.h"
 
 #if TD_DARWIN || TD_LINUX
 #include <unistd.h>
@@ -97,6 +98,10 @@ int main(int argc, char *argv[]) {
     int v = VERBOSITY_NAME(FATAL) + (td::to_integer<int>(arg));
     SET_VERBOSITY_LEVEL(v);
   });
+  p.add_option('V', "version", "shows adnl-pong build information", [&]() {
+    std::cout << "adnl-pong build information: [ Commit: " << GitMetadata::CommitSHA1() << ", Date: " << GitMetadata::CommitDate() << "]\n";
+    std::exit(0);
+  });
   p.add_option('h', "help", "prints_help", [&]() {
     char b[10240];
     td::StringBuilder sb(td::MutableSlice{b, 10000});

adnl/adnl-proxy.cpp

@@ -1,4 +1,4 @@
-/* 
+/*
     This file is part of TON Blockchain source code.
 
     TON Blockchain is free software; you can redistribute it and/or
@@ -14,13 +14,13 @@
     You should have received a copy of the GNU General Public License
     along with TON Blockchain.  If not, see <http://www.gnu.org/licenses/>.
 
-    In addition, as a special exception, the copyright holders give permission 
-    to link the code of portions of this program with the OpenSSL library. 
-    You must obey the GNU General Public License in all respects for all 
-    of the code used other than OpenSSL. If you modify file(s) with this 
-    exception, you may extend this exception to your version of the file(s), 
-    but you are not obligated to do so. If you do not wish to do so, delete this 
-    exception statement from your version. If you delete this exception statement 
+    In addition, as a special exception, the copyright holders give permission
+    to link the code of portions of this program with the OpenSSL library.
+    You must obey the GNU General Public License in all respects for all
+    of the code used other than OpenSSL. If you modify file(s) with this
+    exception, you may extend this exception to your version of the file(s),
+    but you are not obligated to do so. If you do not wish to do so, delete this
+    exception statement from your version. If you delete this exception statement
     from all source files in the program, then also delete it here.
 
     Copyright 2017-2020 Telegram Systems LLP
@@ -43,6 +43,7 @@
 #include "adnl-proxy-types.h"
 #include "adnl-received-mask.h"
 #include <map>
+#include "git.h"
 
 #if TD_DARWIN || TD_LINUX
 #include <unistd.h>
@@ -187,7 +188,6 @@ void Receiver::receive_from_client(td::IPAddress addr, td::BufferSlice data) {
                                  p.data = std::move(data);
                                  p.adnl_start_time = start_time();
                                  p.seqno = out_seqno_;
-                                 p.data = std::move(data);
 
                                  auto enc = proxy_->encrypt(std::move(p));
 
@@ -303,6 +303,10 @@ int main(int argc, char *argv[]) {
     int v = VERBOSITY_NAME(FATAL) + (td::to_integer<int>(arg));
     SET_VERBOSITY_LEVEL(v);
   });
+  p.add_option('V', "version", "shows adnl-proxy build information", [&]() {
+    std::cout << "adnl-proxy build information: [ Commit: " << GitMetadata::CommitSHA1() << ", Date: " << GitMetadata::CommitDate() << "]\n";
+    std::exit(0);
+  });
   p.add_option('h', "help", "prints_help", [&]() {
     char b[10240];
     td::StringBuilder sb(td::MutableSlice{b, 10000});

adnl/adnl-query.cpp

@@ -25,13 +25,16 @@ namespace ton {
 namespace adnl {
 
 void AdnlQuery::alarm() {
-  promise_.set_error(td::Status::Error(ErrorCode::timeout, "adnl query timeout"));
-  stop();
+  set_error(td::Status::Error(ErrorCode::timeout, PSTRING() << "timeout for adnl query " << name_));
 }
 void AdnlQuery::result(td::BufferSlice data) {
   promise_.set_value(std::move(data));
   stop();
 }
+void AdnlQuery::set_error(td::Status error) {
+  promise_.set_error(std::move(error));
+  stop();
+}
 
 AdnlQueryId AdnlQuery::random_query_id() {
   AdnlQueryId q_id;

adnl/adnl-query.h

@@ -48,6 +48,7 @@ class AdnlQuery : public td::actor::Actor {
   }
   void alarm() override;
   void result(td::BufferSlice data);
+  void set_error(td::Status error);
   void start_up() override {
     alarm_timestamp() = timeout_;
   }

adnl/adnl.h

@@ -56,6 +56,7 @@ class AdnlSenderInterface : public td::actor::Actor {
   virtual void send_query_ex(AdnlNodeIdShort src, AdnlNodeIdShort dst, std::string name,
                              td::Promise<td::BufferSlice> promise, td::Timestamp timeout, td::BufferSlice data,
                              td::uint64 max_answer_size) = 0;
+  virtual void get_conn_ip_str(AdnlNodeIdShort l_id, AdnlNodeIdShort p_id, td::Promise<td::string> promise) = 0;
 };
 
 class AdnlTunnel : public td::actor::Actor {};
@@ -96,6 +97,8 @@ class Adnl : public AdnlSenderInterface {
   virtual void add_id_ex(AdnlNodeIdFull id, AdnlAddressList addr_list, td::uint8 cat, td::uint32 mode) = 0;
   virtual void del_id(AdnlNodeIdShort id, td::Promise<td::Unit> promise) = 0;
 
+  virtual void check_id_exists(AdnlNodeIdShort id, td::Promise<bool> promise) = 0;
+
   // subscribe to (some) messages(+queries) to this local id
   virtual void subscribe(AdnlNodeIdShort dst, std::string prefix, std::unique_ptr<Callback> callback) = 0;
   virtual void unsubscribe(AdnlNodeIdShort dst, std::string prefix) = 0;
@@ -118,6 +121,8 @@ class Adnl : public AdnlSenderInterface {
   virtual void create_tunnel(AdnlNodeIdShort dst, td::uint32 size,
                              td::Promise<std::pair<td::actor::ActorOwn<AdnlTunnel>, AdnlAddress>> promise) = 0;
 
+  virtual void get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats>> promise) = 0;
+
   static td::actor::ActorOwn<Adnl> create(std::string db, td::actor::ActorId<keyring::Keyring> keyring);
 
   static std::string int_to_bytestring(td::int32 id) {

adnl/utils.hpp

@@ -40,6 +40,40 @@ inline bool adnl_node_is_older(AdnlNode &a, AdnlNode &b) {
   return a.addr_list().version() < b.addr_list().version();
 }
 
+class RateLimiter {
+public:
+  explicit RateLimiter(td::uint32 capacity, double period) : capacity_(capacity), period_(period), remaining_(capacity) {
+  }
+
+  bool take() {
+    while (remaining_ < capacity_ && increment_at_.is_in_past()) {
+      ++remaining_;
+      increment_at_ += period_;
+    }
+    if (remaining_) {
+      --remaining_;
+      if (increment_at_.is_in_past()) {
+        increment_at_ = td::Timestamp::in(period_);
+      }
+      return true;
+    }
+    return false;
+  }
+
+  td::Timestamp ready_at() const {
+    if (remaining_) {
+      return td::Timestamp::now();
+    }
+    return increment_at_;
+  }
+
+private:
+  td::uint32 capacity_;
+  double period_;
+  td::uint32 remaining_;
+  td::Timestamp increment_at_ = td::Timestamp::never();
+};
+
 }  // namespace adnl
 
 }  // namespace ton

assembly/android/build-android-tonlib.sh

@@ -0,0 +1,60 @@
+with_artifacts=false
+
+while getopts 'a' flag; do
+  case "${flag}" in
+    a) with_artifacts=true ;;
+    *) break
+       ;;
+  esac
+done
+
+export CC=$(which clang-16)
+export CXX=$(which clang++-16)
+export CCACHE_DISABLE=1
+
+if [ ! -d android-ndk-r25b ]; then
+  rm android-ndk-r25b-linux.zip
+  echo "Downloading https://dl.google.com/android/repository/android-ndk-r25b-linux.zip"
+  wget -q https://dl.google.com/android/repository/android-ndk-r25b-linux.zip
+  unzip -q android-ndk-r25b-linux.zip
+  test $? -eq 0 || { echo "Can't unzip android-ndk-r25b-linux.zip"; exit 1; }
+  echo "Android NDK extracted"
+else
+  echo "Using extracted Android NDK"
+fi
+
+export JAVA_AWT_LIBRARY=NotNeeded
+export JAVA_JVM_LIBRARY=NotNeeded
+export JAVA_INCLUDE_PATH=${JAVA_HOME}/include
+export JAVA_AWT_INCLUDE_PATH=${JAVA_HOME}/include
+export JAVA_INCLUDE_PATH2=${JAVA_HOME}/include/linux
+
+export ANDROID_NDK_ROOT=$(pwd)/android-ndk-r25b
+export NDK_PLATFORM="android-21"
+export ANDROID_PLATFORM="android-21"
+export OPENSSL_DIR=$(pwd)/example/android/third_party/crypto
+
+rm -rf example/android/src/drinkless/org/ton/TonApi.java
+cd example/android/
+
+rm CMakeCache.txt .ninja_*
+cmake -GNinja -DTON_ONLY_TONLIB=ON .
+
+test $? -eq 0 || { echo "Can't configure TON"; exit 1; }
+
+ninja prepare_cross_compiling
+
+test $? -eq 0 || { echo "Can't compile prepare_cross_compiling"; exit 1; }
+
+rm CMakeCache.txt .ninja_*
+
+. ./build-all.sh
+
+find . -name "*.debug" -type f -delete
+
+if [ "$with_artifacts" = true ]; then
+  cd ../..
+  mkdir -p artifacts/tonlib-android-jni
+  cp example/android/src/drinkless/org/ton/TonApi.java artifacts/tonlib-android-jni/
+  cp -R example/android/libs/* artifacts/tonlib-android-jni/
+fi

assembly/appimage/AppRun

@@ -0,0 +1,3 @@
+#!/bin/sh
+export LD_LIBRARY_PATH="${APPDIR}/usr/lib:${LD_LIBRARY_PATH}"
+exec "$(dirname $0)"/usr/bin/app "$@"

assembly/appimage/create-appimages.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+if [ ! -d "artifacts" ]; then
+  echo "No artifacts found."
+  exit 2
+fi
+# x86_64 or aarch64
+ARCH=$1
+
+rm -rf appimages
+
+mkdir -p appimages/artifacts
+
+wget -nc https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-$ARCH.AppImage
+chmod +x ./appimagetool-$ARCH.AppImage
+
+cd appimages
+for file in ../artifacts/*; do
+  if [[ -f "$file" && "$file" != *.so ]]; then
+    appName=$(basename "$file")
+    echo $appName
+    # prepare AppDir
+    mkdir -p $appName.AppDir/usr/{bin,lib}
+    cp ../AppRun $appName.AppDir/AppRun
+    sed -i "s/app/$appName/g" $appName.AppDir/AppRun
+    chmod +x ./$appName.AppDir/AppRun
+    printf '[Desktop Entry]\nName='$appName'\nExec='$appName'\nIcon='$appName'\nType=Application\nCategories=Utility;\n' > $appName.AppDir/$appName.desktop
+    cp ../ton.png $appName.AppDir/$appName.png
+    cp $file $appName.AppDir/usr/bin/
+    cp ../build/openssl_3/libcrypto.so.3 \
+      /lib/$ARCH-linux-gnu/libatomic.so.1 \
+      /lib/$ARCH-linux-gnu/libsodium.so.23 \
+      /lib/$ARCH-linux-gnu/libz.so.1 \
+      /lib/$ARCH-linux-gnu/liblz4.so.1 \
+      /lib/$ARCH-linux-gnu/libmicrohttpd.so.12 \
+      /lib/$ARCH-linux-gnu/libreadline.so.8 \
+      /lib/$ARCH-linux-gnu/libstdc++.so.6 \
+      $appName.AppDir/usr/lib/
+
+    chmod +x ./$appName.AppDir/usr/bin/$appName
+    # create AppImage
+    ./../appimagetool-$ARCH.AppImage -l $appName.AppDir
+    mv $appName-$ARCH.AppImage artifacts/$appName
+  fi
+done
+
+ls -larth artifacts
+cp -r ../artifacts/{smartcont,lib} artifacts/
+pwd
+ls -larth artifacts

assembly/native/build-macos-portable.sh

@@ -0,0 +1,189 @@
+#/bin/bash
+
+with_tests=false
+with_artifacts=false
+OSX_TARGET=10.15
+
+
+while getopts 'tao:' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    a) with_artifacts=true ;;
+    o) OSX_TARGET=${OPTARG} ;;
+    *) break
+       ;;
+  esac
+done
+
+if [ ! -d "build" ]; then
+  mkdir build
+  cd build
+else
+  cd build
+  rm -rf .ninja* CMakeCache.txt
+fi
+
+export NONINTERACTIVE=1
+brew install ninja pkg-config automake libtool autoconf texinfo
+brew install llvm@16
+
+
+if [ -f /opt/homebrew/opt/llvm@16/bin/clang ]; then
+  export CC=/opt/homebrew/opt/llvm@16/bin/clang
+  export CXX=/opt/homebrew/opt/llvm@16/bin/clang++
+else
+  export CC=/usr/local/opt/llvm@16/bin/clang
+  export CXX=/usr/local/opt/llvm@16/bin/clang++
+fi
+export CCACHE_DISABLE=1
+
+if [ ! -d "lz4" ]; then
+git clone https://github.com/lz4/lz4.git
+cd lz4
+lz4Path=`pwd`
+git checkout v1.9.4
+make -j12
+test $? -eq 0 || { echo "Can't compile lz4"; exit 1; }
+cd ..
+# ./lib/liblz4.a
+# ./lib
+else
+  lz4Path=$(pwd)/lz4
+  echo "Using compiled lz4"
+fi
+
+if [ ! -d "libsodium" ]; then
+  export LIBSODIUM_FULL_BUILD=1
+  git clone https://github.com/jedisct1/libsodium.git
+  cd libsodium
+  sodiumPath=`pwd`
+  git checkout 1.0.18
+  ./autogen.sh
+  ./configure --with-pic --enable-static
+  make -j12
+  test $? -eq 0 || { echo "Can't compile libsodium"; exit 1; }
+  cd ..
+else
+  sodiumPath=$(pwd)/libsodium
+  echo "Using compiled libsodium"
+fi
+
+if [ ! -d "openssl_3" ]; then
+  git clone https://github.com/openssl/openssl openssl_3
+  cd openssl_3
+  opensslPath=`pwd`
+  git checkout openssl-3.1.4
+  ./config
+  make build_libs -j12
+  test $? -eq 0 || { echo "Can't compile openssl_3"; exit 1; }
+  cd ..
+else
+  opensslPath=$(pwd)/openssl_3
+  echo "Using compiled openssl_3"
+fi
+
+if [ ! -d "zlib" ]; then
+  git clone https://github.com/madler/zlib.git
+  cd zlib
+  zlibPath=`pwd`
+  ./configure --static
+  make -j12
+  test $? -eq 0 || { echo "Can't compile zlib"; exit 1; }
+  cd ..
+else
+  zlibPath=$(pwd)/zlib
+  echo "Using compiled zlib"
+fi
+
+if [ ! -d "libmicrohttpd" ]; then
+  git clone https://git.gnunet.org/libmicrohttpd.git
+  cd libmicrohttpd
+  libmicrohttpdPath=`pwd`
+  ./autogen.sh
+  ./configure --enable-static --disable-tests --disable-benchmark --disable-shared --disable-https --with-pic
+  make -j12
+  test $? -eq 0 || { echo "Can't compile libmicrohttpd"; exit 1; }
+  cd ..
+else
+  libmicrohttpdPath=$(pwd)/libmicrohttpd
+  echo "Using compiled libmicrohttpd"
+fi
+
+cmake -GNinja .. \
+-DPORTABLE=1 \
+-DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=$OSX_TARGET \
+-DCMAKE_CXX_FLAGS="-stdlib=libc++" \
+-DCMAKE_BUILD_TYPE=Release \
+-DOPENSSL_FOUND=1 \
+-DOPENSSL_INCLUDE_DIR=$opensslPath/include \
+-DOPENSSL_CRYPTO_LIBRARY=$opensslPath/libcrypto.a \
+-DZLIB_FOUND=1 \
+-DZLIB_INCLUDE_DIR=$zlibPath \
+-DZLIB_LIBRARIES=$zlibPath/libz.a \
+-DSODIUM_FOUND=1 \
+-DSODIUM_INCLUDE_DIR=$sodiumPath/src/libsodium/include \
+-DSODIUM_LIBRARY_RELEASE=$sodiumPath/src/libsodium/.libs/libsodium.a \
+-DMHD_FOUND=1 \
+-DMHD_INCLUDE_DIR=$libmicrohttpdPath/src/include \
+-DMHD_LIBRARY=$libmicrohttpdPath/src/microhttpd/.libs/libmicrohttpd.a \
+-DLZ4_FOUND=1 \
+-DLZ4_INCLUDE_DIRS=$lz4Path/lib \
+-DLZ4_LIBRARIES=$lz4Path/lib/liblz4.a
+
+
+test $? -eq 0 || { echo "Can't configure ton"; exit 1; }
+
+if [ "$with_tests" = true ]; then
+  ninja storage-daemon storage-daemon-cli blockchain-explorer   \
+  tonlib tonlibjson tonlib-cli validator-engine func tolk fift \
+  lite-client pow-miner validator-engine-console generate-random-id json2tlo dht-server \
+  http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork tlbc emulator \
+  test-ed25519 test-ed25519-crypto test-bigint test-vm test-fift test-cells test-smartcont \
+  test-net test-tdactor test-tdutils test-tonlib-offline test-adnl test-dht test-rldp \
+  test-rldp2 test-catchain test-fec test-tddb test-db test-validator-session-state test-emulator proxy-liteserver
+  test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+else
+  ninja storage-daemon storage-daemon-cli blockchain-explorer   \
+  tonlib tonlibjson tonlib-cli validator-engine func tolk fift \
+  lite-client pow-miner validator-engine-console generate-random-id json2tlo dht-server \
+  http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork tlbc emulator proxy-liteserver
+  test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+fi
+
+cd ..
+
+if [ "$with_artifacts" = true ]; then
+  echo Creating artifacts...
+  rm -rf artifacts
+  mkdir artifacts
+  cp build/storage/storage-daemon/storage-daemon artifacts/
+  cp build/storage/storage-daemon/storage-daemon-cli artifacts/
+  cp build/blockchain-explorer/blockchain-explorer artifacts/
+  cp build/crypto/fift artifacts/
+  cp build/crypto/func artifacts/
+  cp build/tolk/tolk artifacts/
+  cp build/crypto/create-state artifacts/
+  cp build/crypto/tlbc artifacts/
+  cp build/validator-engine-console/validator-engine-console artifacts/
+  cp build/tonlib/tonlib-cli artifacts/
+  cp build/tonlib/libtonlibjson.0.5.dylib artifacts/libtonlibjson.dylib
+  cp build/http/http-proxy artifacts/
+  cp build/rldp-http-proxy/rldp-http-proxy artifacts/
+  cp build/dht-server/dht-server artifacts/
+  cp build/lite-client/lite-client artifacts/
+  cp build/validator-engine/validator-engine artifacts/
+  cp build/utils/generate-random-id artifacts/
+  cp build/utils/json2tlo artifacts/
+  cp build/utils/proxy-liteserver artifacts/
+  cp build/adnl/adnl-proxy artifacts/
+  cp build/emulator/libemulator.dylib artifacts/
+  rsync -r crypto/smartcont artifacts/
+  rsync -r crypto/fift/lib artifacts/
+  chmod -R +x artifacts/*
+fi
+
+if [ "$with_tests" = true ]; then
+  cd build
+#  ctest --output-on-failure -E "test-catchain|test-actors"
+  ctest --output-on-failure
+fi

assembly/native/build-macos-shared.sh

@@ -0,0 +1,117 @@
+#/bin/bash
+
+with_tests=false
+with_artifacts=false
+OSX_TARGET=10.15
+
+
+while getopts 'tao:' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    a) with_artifacts=true ;;
+    o) OSX_TARGET=${OPTARG} ;;
+    *) break
+       ;;
+  esac
+done
+
+if [ ! -d "build" ]; then
+  mkdir build
+  cd build
+else
+  cd build
+  rm -rf .ninja* CMakeCache.txt
+fi
+
+export NONINTERACTIVE=1
+brew install ninja libsodium libmicrohttpd pkg-config automake libtool autoconf gnutls
+brew install llvm@16
+
+if [ -f /opt/homebrew/opt/llvm@16/bin/clang ]; then
+  export CC=/opt/homebrew/opt/llvm@16/bin/clang
+  export CXX=/opt/homebrew/opt/llvm@16/bin/clang++
+else
+  export CC=/usr/local/opt/llvm@16/bin/clang
+  export CXX=/usr/local/opt/llvm@16/bin/clang++
+fi
+export CCACHE_DISABLE=1
+
+if [ ! -d "lz4" ]; then
+  git clone https://github.com/lz4/lz4
+  cd lz4
+  lz4Path=`pwd`
+  git checkout v1.9.4
+  make -j12
+  test $? -eq 0 || { echo "Can't compile lz4"; exit 1; }
+  cd ..
+else
+  lz4Path=$(pwd)/lz4
+  echo "Using compiled lz4"
+fi
+
+brew unlink openssl@1.1
+brew install openssl@3
+brew unlink openssl@3 &&  brew link --overwrite openssl@3
+
+cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. \
+-DCMAKE_CXX_FLAGS="-stdlib=libc++" \
+-DLZ4_FOUND=1 \
+-DLZ4_LIBRARIES=$lz4Path/lib/liblz4.a \
+-DLZ4_INCLUDE_DIRS=$lz4Path/lib
+
+test $? -eq 0 || { echo "Can't configure ton"; exit 1; }
+
+if [ "$with_tests" = true ]; then
+  ninja storage-daemon storage-daemon-cli blockchain-explorer   \
+  tonlib tonlibjson tonlib-cli validator-engine func tolk fift \
+  lite-client pow-miner validator-engine-console generate-random-id json2tlo dht-server \
+  http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork tlbc emulator \
+  test-ed25519 test-ed25519-crypto test-bigint test-vm test-fift test-cells test-smartcont \
+  test-net test-tdactor test-tdutils test-tonlib-offline test-adnl test-dht test-rldp \
+  test-rldp2 test-catchain test-fec test-tddb test-db test-validator-session-state test-emulator proxy-liteserver
+  test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+else
+  ninja storage-daemon storage-daemon-cli blockchain-explorer   \
+  tonlib tonlibjson tonlib-cli validator-engine func tolk fift \
+  lite-client pow-miner validator-engine-console generate-random-id json2tlo dht-server \
+  http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork tlbc emulator proxy-liteserver
+  test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+fi
+
+cd ..
+
+if [ "$with_artifacts" = true ]; then
+  echo Creating artifacts...
+  rm -rf artifacts
+  mkdir artifacts
+  cp build/storage/storage-daemon/storage-daemon artifacts/
+  cp build/storage/storage-daemon/storage-daemon-cli artifacts/
+  cp build/blockchain-explorer/blockchain-explorer artifacts/
+  cp build/crypto/fift artifacts/
+  cp build/crypto/func artifacts/
+  cp build/tolk/tolk artifacts/
+  cp build/crypto/create-state artifacts/
+  cp build/crypto/tlbc artifacts/
+  cp build/validator-engine-console/validator-engine-console artifacts/
+  cp build/tonlib/tonlib-cli artifacts/
+  cp build/tonlib/libtonlibjson.0.5.dylib artifacts/libtonlibjson.dylib
+  cp build/http/http-proxy artifacts/
+  cp build/rldp-http-proxy/rldp-http-proxy artifacts/
+  cp build/dht-server/dht-server artifacts/
+  cp build/lite-client/lite-client artifacts/
+  cp build/validator-engine/validator-engine artifacts/
+  cp build/utils/generate-random-id artifacts/
+  cp build/utils/json2tlo artifacts/
+  cp build/utils/proxy-liteserver artifacts/
+  cp build/adnl/adnl-proxy artifacts/
+  cp build/emulator/libemulator.dylib artifacts/
+  cp -R crypto/smartcont artifacts/
+  cp -R crypto/fift/lib artifacts/
+  chmod -R +x artifacts/*
+fi
+
+if [ "$with_tests" = true ]; then
+  cd build
+#  ctest --output-on-failure -E "test-catchain|test-actors"
+  ctest --output-on-failure --timeout 1800
+fi

assembly/native/build-ubuntu-appimages.sh

@@ -0,0 +1,109 @@
+#/bin/bash
+
+with_tests=false
+with_artifacts=false
+
+
+while getopts 'ta' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    a) with_artifacts=true ;;
+    *) break
+       ;;
+  esac
+done
+
+if [ ! -d "build" ]; then
+  mkdir build
+  cd build
+else
+  cd build
+  rm -rf .ninja* CMakeCache.txt
+fi
+
+export CC=$(which clang-16)
+export CXX=$(which clang++-16)
+export CCACHE_DISABLE=1
+
+if [ ! -d "openssl_3" ]; then
+  git clone https://github.com/openssl/openssl openssl_3
+  cd openssl_3
+  opensslPath=`pwd`
+  git checkout openssl-3.1.4
+  ./config
+  make build_libs -j12
+  test $? -eq 0 || { echo "Can't compile openssl_3"; exit 1; }
+  cd ..
+else
+  opensslPath=$(pwd)/openssl_3
+  echo "Using compiled openssl_3"
+fi
+
+cmake -GNinja .. \
+-DCMAKE_BUILD_TYPE=Release \
+-DPORTABLE=1 \
+-DOPENSSL_ROOT_DIR=$opensslPath \
+-DOPENSSL_INCLUDE_DIR=$opensslPath/include \
+-DOPENSSL_CRYPTO_LIBRARY=$opensslPath/libcrypto.so
+
+
+test $? -eq 0 || { echo "Can't configure ton"; exit 1; }
+
+if [ "$with_tests" = true ]; then
+ninja storage-daemon storage-daemon-cli fift func tolk tonlib tonlibjson tonlib-cli \
+      validator-engine lite-client pow-miner validator-engine-console blockchain-explorer \
+      generate-random-id json2tlo dht-server http-proxy rldp-http-proxy \
+      adnl-proxy create-state emulator test-ed25519 test-ed25519-crypto test-bigint \
+      test-vm test-fift test-cells test-smartcont test-net test-tdactor test-tdutils \
+      test-tonlib-offline test-adnl test-dht test-rldp test-rldp2 test-catchain \
+      test-fec test-tddb test-db test-validator-session-state test-emulator proxy-liteserver
+      test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+else
+ninja storage-daemon storage-daemon-cli fift func tolk tonlib tonlibjson tonlib-cli \
+      validator-engine lite-client pow-miner validator-engine-console blockchain-explorer \
+      generate-random-id json2tlo dht-server http-proxy rldp-http-proxy \
+      adnl-proxy create-state emulator proxy-liteserver
+      test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+fi
+
+# simple binaries' test
+./storage/storage-daemon/storage-daemon -V || exit 1
+./validator-engine/validator-engine -V || exit 1
+./lite-client/lite-client -V || exit 1
+./crypto/fift  -V || exit 1
+
+echo validator-engine
+ldd ./validator-engine/validator-engine || exit 1
+ldd ./validator-engine-console/validator-engine-console || exit 1
+ldd ./crypto/fift || exit 1
+echo blockchain-explorer
+ldd ./blockchain-explorer/blockchain-explorer || exit 1
+echo libtonlibjson.so
+ldd ./tonlib/libtonlibjson.so.0.5 || exit 1
+echo libemulator.so
+ldd ./emulator/libemulator.so  || exit 1
+
+cd ..
+
+if [ "$with_artifacts" = true ]; then
+  rm -rf artifacts
+  mkdir artifacts
+  mv build/tonlib/libtonlibjson.so.0.5 build/tonlib/libtonlibjson.so
+  cp build/storage/storage-daemon/storage-daemon build/storage/storage-daemon/storage-daemon-cli \
+     build/crypto/fift build/crypto/tlbc build/crypto/func build/tolk/tolk build/crypto/create-state build/blockchain-explorer/blockchain-explorer \
+     build/validator-engine-console/validator-engine-console build/tonlib/tonlib-cli build/utils/proxy-liteserver \
+     build/tonlib/libtonlibjson.so build/http/http-proxy build/rldp-http-proxy/rldp-http-proxy \
+     build/dht-server/dht-server build/lite-client/lite-client build/validator-engine/validator-engine \
+     build/utils/generate-random-id build/utils/json2tlo build/adnl/adnl-proxy build/emulator/libemulator.so \
+     artifacts
+  test $? -eq 0 || { echo "Can't copy final binaries"; exit 1; }
+  cp -R crypto/smartcont artifacts
+  cp -R crypto/fift/lib artifacts
+  chmod -R +x artifacts/*
+fi
+
+if [ "$with_tests" = true ]; then
+  cd build
+#  ctest --output-on-failure -E "test-catchain|test-actors|test-smartcont|test-adnl|test-validator-session-state|test-dht|test-rldp"
+  ctest --output-on-failure --timeout 1800
+fi

assembly/native/build-ubuntu-portable-libs.sh

@@ -0,0 +1,132 @@
+#/bin/bash
+
+#sudo apt-get update
+#sudo apt-get install -y build-essential git cmake ninja-build automake libtool texinfo autoconf libc++-dev libc++abi-dev
+
+with_artifacts=false
+
+while getopts 'ta' flag; do
+  case "${flag}" in
+    a) with_artifacts=true ;;
+    *) break
+       ;;
+  esac
+done
+
+if [ ! -d "build" ]; then
+  mkdir build
+  cd build
+else
+  cd build
+  rm -rf .ninja* CMakeCache.txt
+fi
+
+export CC=$(which clang)
+export CXX=$(which clang++)
+export CCACHE_DISABLE=1
+
+if [ ! -d "lz4" ]; then
+git clone https://github.com/lz4/lz4.git
+cd lz4
+lz4Path=`pwd`
+git checkout v1.9.4
+CFLAGS="-fPIC" make -j12
+test $? -eq 0 || { echo "Can't compile lz4"; exit 1; }
+cd ..
+# ./lib/liblz4.a
+# ./lib
+else
+  lz4Path=$(pwd)/lz4
+  echo "Using compiled lz4"
+fi
+
+if [ ! -d "libsodium" ]; then
+  export LIBSODIUM_FULL_BUILD=1
+  git clone https://github.com/jedisct1/libsodium.git
+  cd libsodium
+  sodiumPath=`pwd`
+  git checkout 1.0.18
+  ./autogen.sh
+  ./configure --with-pic --enable-static
+  make -j12
+  test $? -eq 0 || { echo "Can't compile libsodium"; exit 1; }
+  cd ..
+else
+  sodiumPath=$(pwd)/libsodium
+  echo "Using compiled libsodium"
+fi
+
+if [ ! -d "openssl_3" ]; then
+  git clone https://github.com/openssl/openssl openssl_3
+  cd openssl_3
+  opensslPath=`pwd`
+  git checkout openssl-3.1.4
+  ./config
+  make build_libs -j12
+  test $? -eq 0 || { echo "Can't compile openssl_3"; exit 1; }
+  cd ..
+else
+  opensslPath=$(pwd)/openssl_3
+  echo "Using compiled openssl_3"
+fi
+
+if [ ! -d "zlib" ]; then
+  git clone https://github.com/madler/zlib.git
+  cd zlib
+  zlibPath=`pwd`
+  ./configure --static
+  make -j12
+  test $? -eq 0 || { echo "Can't compile zlib"; exit 1; }
+  cd ..
+else
+  zlibPath=$(pwd)/zlib
+  echo "Using compiled zlib"
+fi
+
+if [ ! -d "libmicrohttpd" ]; then
+  git clone https://git.gnunet.org/libmicrohttpd.git
+  cd libmicrohttpd
+  libmicrohttpdPath=`pwd`
+  ./autogen.sh
+  ./configure --enable-static --disable-tests --disable-benchmark --disable-shared --disable-https --with-pic
+  make -j12
+  test $? -eq 0 || { echo "Can't compile libmicrohttpd"; exit 1; }
+  cd ..
+else
+  libmicrohttpdPath=$(pwd)/libmicrohttpd
+  echo "Using compiled libmicrohttpd"
+fi
+
+cmake -GNinja .. \
+-DPORTABLE=1 \
+-DCMAKE_BUILD_TYPE=Release \
+-DOPENSSL_FOUND=1 \
+-DOPENSSL_INCLUDE_DIR=$opensslPath/include \
+-DOPENSSL_CRYPTO_LIBRARY=$opensslPath/libcrypto.a \
+-DZLIB_FOUND=1 \
+-DZLIB_INCLUDE_DIR=$zlibPath \
+-DZLIB_LIBRARIES=$zlibPath/libz.a \
+-DSODIUM_FOUND=1 \
+-DSODIUM_INCLUDE_DIR=$sodiumPath/src/libsodium/include \
+-DSODIUM_LIBRARY_RELEASE=$sodiumPath/src/libsodium/.libs/libsodium.a \
+-DMHD_FOUND=1 \
+-DMHD_INCLUDE_DIR=$libmicrohttpdPath/src/include \
+-DMHD_LIBRARY=$libmicrohttpdPath/src/microhttpd/.libs/libmicrohttpd.a \
+-DLZ4_FOUND=1 \
+-DLZ4_INCLUDE_DIRS=$lz4Path/lib \
+-DLZ4_LIBRARIES=$lz4Path/lib/liblz4.a
+
+
+
+test $? -eq 0 || { echo "Can't configure ton"; exit 1; }
+
+ninja tonlibjson emulator
+test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+
+cd ..
+
+mkdir artifacts
+mv build/tonlib/libtonlibjson.so.0.5 build/tonlib/libtonlibjson.so
+cp build/tonlib/libtonlibjson.so \
+   build/emulator/libemulator.so \
+   artifacts

assembly/native/build-ubuntu-portable.sh

@@ -0,0 +1,172 @@
+#/bin/bash
+
+#sudo apt-get update
+#sudo apt-get install -y build-essential git cmake ninja-build automake libtool texinfo autoconf libc++-dev libc++abi-dev
+
+with_tests=false
+with_artifacts=false
+
+
+while getopts 'ta' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    a) with_artifacts=true ;;
+    *) break
+       ;;
+  esac
+done
+
+if [ ! -d "build" ]; then
+  mkdir build
+  cd build
+else
+  cd build
+  rm -rf .ninja* CMakeCache.txt
+fi
+
+export CC=$(which clang)
+export CXX=$(which clang++)
+export CCACHE_DISABLE=1
+
+if [ ! -d "lz4" ]; then
+git clone https://github.com/lz4/lz4.git
+cd lz4
+lz4Path=`pwd`
+git checkout v1.9.4
+CFLAGS="-fPIC" make -j12
+test $? -eq 0 || { echo "Can't compile lz4"; exit 1; }
+cd ..
+# ./lib/liblz4.a
+# ./lib
+else
+  lz4Path=$(pwd)/lz4
+  echo "Using compiled lz4"
+fi
+
+if [ ! -d "libsodium" ]; then
+  export LIBSODIUM_FULL_BUILD=1
+  git clone https://github.com/jedisct1/libsodium.git
+  cd libsodium
+  sodiumPath=`pwd`
+  git checkout 1.0.18
+  ./autogen.sh
+  ./configure --with-pic --enable-static
+  make -j12
+  test $? -eq 0 || { echo "Can't compile libsodium"; exit 1; }
+  cd ..
+else
+  sodiumPath=$(pwd)/libsodium
+  echo "Using compiled libsodium"
+fi
+
+if [ ! -d "openssl_3" ]; then
+  git clone https://github.com/openssl/openssl openssl_3
+  cd openssl_3
+  opensslPath=`pwd`
+  git checkout openssl-3.1.4
+  ./config
+  make build_libs -j12
+  test $? -eq 0 || { echo "Can't compile openssl_3"; exit 1; }
+  cd ..
+else
+  opensslPath=$(pwd)/openssl_3
+  echo "Using compiled openssl_3"
+fi
+
+if [ ! -d "zlib" ]; then
+  git clone https://github.com/madler/zlib.git
+  cd zlib
+  zlibPath=`pwd`
+  ./configure --static
+  make -j12
+  test $? -eq 0 || { echo "Can't compile zlib"; exit 1; }
+  cd ..
+else
+  zlibPath=$(pwd)/zlib
+  echo "Using compiled zlib"
+fi
+
+if [ ! -d "libmicrohttpd" ]; then
+  git clone https://git.gnunet.org/libmicrohttpd.git
+  cd libmicrohttpd
+  libmicrohttpdPath=`pwd`
+  ./autogen.sh
+  ./configure --enable-static --disable-tests --disable-benchmark --disable-shared --disable-https --with-pic
+  make -j12
+  test $? -eq 0 || { echo "Can't compile libmicrohttpd"; exit 1; }
+  cd ..
+else
+  libmicrohttpdPath=$(pwd)/libmicrohttpd
+  echo "Using compiled libmicrohttpd"
+fi
+
+cmake -GNinja .. \
+-DPORTABLE=1 \
+-DCMAKE_BUILD_TYPE=Release \
+-DOPENSSL_FOUND=1 \
+-DOPENSSL_INCLUDE_DIR=$opensslPath/include \
+-DOPENSSL_CRYPTO_LIBRARY=$opensslPath/libcrypto.a \
+-DZLIB_FOUND=1 \
+-DZLIB_INCLUDE_DIR=$zlibPath \
+-DZLIB_LIBRARIES=$zlibPath/libz.a \
+-DSODIUM_FOUND=1 \
+-DSODIUM_INCLUDE_DIR=$sodiumPath/src/libsodium/include \
+-DSODIUM_LIBRARY_RELEASE=$sodiumPath/src/libsodium/.libs/libsodium.a \
+-DMHD_FOUND=1 \
+-DMHD_INCLUDE_DIR=$libmicrohttpdPath/src/include \
+-DMHD_LIBRARY=$libmicrohttpdPath/src/microhttpd/.libs/libmicrohttpd.a \
+-DLZ4_FOUND=1 \
+-DLZ4_INCLUDE_DIRS=$lz4Path/lib \
+-DLZ4_LIBRARIES=$lz4Path/lib/liblz4.a
+
+
+
+test $? -eq 0 || { echo "Can't configure ton"; exit 1; }
+
+if [ "$with_tests" = true ]; then
+ninja storage-daemon storage-daemon-cli fift func tolk tonlib tonlibjson tonlib-cli \
+      validator-engine lite-client pow-miner validator-engine-console blockchain-explorer \
+      generate-random-id json2tlo dht-server http-proxy rldp-http-proxy \
+      adnl-proxy create-state emulator test-ed25519 test-ed25519-crypto test-bigint \
+      test-vm test-fift test-cells test-smartcont test-net test-tdactor test-tdutils \
+      test-tonlib-offline test-adnl test-dht test-rldp test-rldp2 test-catchain \
+      test-fec test-tddb test-db test-validator-session-state test-emulator proxy-liteserver
+      test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+else
+ninja storage-daemon storage-daemon-cli fift func tolk tonlib tonlibjson tonlib-cli \
+      validator-engine lite-client pow-miner validator-engine-console blockchain-explorer \
+      generate-random-id json2tlo dht-server http-proxy rldp-http-proxy \
+      adnl-proxy create-state emulator proxy-liteserver
+      test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+fi
+
+# simple binaries' test
+./storage/storage-daemon/storage-daemon -V || exit 1
+./validator-engine/validator-engine -V || exit 1
+./lite-client/lite-client -V || exit 1
+./crypto/fift  -V || exit 1
+
+cd ..
+
+if [ "$with_artifacts" = true ]; then
+  rm -rf artifacts
+  mkdir artifacts
+  mv build/tonlib/libtonlibjson.so.0.5 build/tonlib/libtonlibjson.so
+  cp build/storage/storage-daemon/storage-daemon build/storage/storage-daemon/storage-daemon-cli \
+     build/crypto/fift build/crypto/tlbc build/crypto/func build/tolk/tolk build/crypto/create-state build/blockchain-explorer/blockchain-explorer \
+     build/validator-engine-console/validator-engine-console build/tonlib/tonlib-cli build/utils/proxy-liteserver \
+     build/tonlib/libtonlibjson.so build/http/http-proxy build/rldp-http-proxy/rldp-http-proxy \
+     build/dht-server/dht-server build/lite-client/lite-client build/validator-engine/validator-engine \
+     build/utils/generate-random-id build/utils/json2tlo build/adnl/adnl-proxy build/emulator/libemulator.so \
+     artifacts
+  test $? -eq 0 || { echo "Can't copy final binaries"; exit 1; }
+  cp -R crypto/smartcont artifacts
+  cp -R crypto/fift/lib artifacts
+  chmod -R +x artifacts/*
+fi
+
+if [ "$with_tests" = true ]; then
+  cd build
+#  ctest --output-on-failure -E "test-catchain|test-actors|test-smartcont|test-adnl|test-validator-session-state|test-dht|test-rldp"
+  ctest --output-on-failure -E "test-adnl"
+fi

assembly/native/build-ubuntu-shared.sh

@@ -0,0 +1,102 @@
+#/bin/bash
+
+#sudo apt-get update
+#sudo apt-get install -y build-essential git cmake ninja-build zlib1g-dev libsecp256k1-dev libmicrohttpd-dev libsodium-dev liblz4-dev libjemalloc-dev
+
+with_tests=false
+with_artifacts=false
+
+
+while getopts 'ta' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    a) with_artifacts=true ;;
+    *) break
+       ;;
+  esac
+done
+
+if [ ! -d "build" ]; then
+  mkdir build
+  cd build
+else
+  cd build
+  rm -rf .ninja* CMakeCache.txt
+fi
+
+export CC=$(which clang-16)
+export CXX=$(which clang++-16)
+export CCACHE_DISABLE=1
+
+if [ ! -d "openssl_3" ]; then
+  git clone https://github.com/openssl/openssl openssl_3
+  cd openssl_3
+  opensslPath=`pwd`
+  git checkout openssl-3.1.4
+  ./config
+  make build_libs -j12
+  test $? -eq 0 || { echo "Can't compile openssl_3"; exit 1; }
+  cd ..
+else
+  opensslPath=$(pwd)/openssl_3
+  echo "Using compiled openssl_3"
+fi
+
+cmake -GNinja -DTON_USE_JEMALLOC=ON .. \
+-DCMAKE_BUILD_TYPE=Release \
+-DOPENSSL_ROOT_DIR=$opensslPath \
+-DOPENSSL_INCLUDE_DIR=$opensslPath/include \
+-DOPENSSL_CRYPTO_LIBRARY=$opensslPath/libcrypto.so
+
+
+test $? -eq 0 || { echo "Can't configure ton"; exit 1; }
+
+if [ "$with_tests" = true ]; then
+ninja storage-daemon storage-daemon-cli fift func tolk tonlib tonlibjson tonlib-cli \
+      validator-engine lite-client pow-miner validator-engine-console blockchain-explorer \
+      generate-random-id json2tlo dht-server http-proxy rldp-http-proxy \
+      adnl-proxy create-state emulator test-ed25519 test-ed25519-crypto test-bigint \
+      test-vm test-fift test-cells test-smartcont test-net test-tdactor test-tdutils \
+      test-tonlib-offline test-adnl test-dht test-rldp test-rldp2 test-catchain \
+      test-fec test-tddb test-db test-validator-session-state test-emulator proxy-liteserver
+      test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+else
+ninja storage-daemon storage-daemon-cli fift func tolk tonlib tonlibjson tonlib-cli \
+      validator-engine lite-client pow-miner validator-engine-console blockchain-explorer \
+      generate-random-id json2tlo dht-server http-proxy rldp-http-proxy \
+      adnl-proxy create-state emulator proxy-liteserver
+      test $? -eq 0 || { echo "Can't compile ton"; exit 1; }
+fi
+
+# simple binaries' test
+./storage/storage-daemon/storage-daemon -V || exit 1
+./validator-engine/validator-engine -V || exit 1
+./lite-client/lite-client -V || exit 1
+./crypto/fift  -V || exit 1
+
+ldd ./validator-engine/validator-engine || exit 1
+
+cd ..
+
+if [ "$with_artifacts" = true ]; then
+  rm -rf artifacts
+  mkdir artifacts
+  mv build/tonlib/libtonlibjson.so.0.5 build/tonlib/libtonlibjson.so
+  cp build/storage/storage-daemon/storage-daemon build/storage/storage-daemon/storage-daemon-cli \
+     build/crypto/fift build/crypto/tlbc build/crypto/func build/tolk/tolk build/crypto/create-state build/blockchain-explorer/blockchain-explorer \
+     build/validator-engine-console/validator-engine-console build/tonlib/tonlib-cli build/utils/proxy-liteserver \
+     build/tonlib/libtonlibjson.so build/http/http-proxy build/rldp-http-proxy/rldp-http-proxy \
+     build/dht-server/dht-server build/lite-client/lite-client build/validator-engine/validator-engine \
+     build/utils/generate-random-id build/utils/json2tlo build/adnl/adnl-proxy build/emulator/libemulator.so \
+     artifacts
+  test $? -eq 0 || { echo "Can't copy final binaries"; exit 1; }
+  cp -R crypto/smartcont artifacts
+  cp -R crypto/fift/lib artifacts
+  chmod -R +x artifacts/*
+fi
+
+if [ "$with_tests" = true ]; then
+  cd build
+#  ctest --output-on-failure -E "test-catchain|test-actors|test-smartcont|test-adnl|test-validator-session-state|test-dht|test-rldp"
+  ctest --output-on-failure --timeout 1800
+fi

assembly/native/build-windows-2019.bat

@@ -0,0 +1,208 @@
+REM execute this script inside elevated (Run as Administrator) console "x64 Native Tools Command Prompt for VS 2019"
+
+echo off
+
+echo Installing chocolatey windows package manager...
+@"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin"
+choco -?
+IF %errorlevel% NEQ 0 (
+  echo Can't install chocolatey
+  exit /b %errorlevel%
+)
+
+choco feature enable -n allowEmptyChecksums
+
+echo Installing pkgconfiglite...
+choco install -y pkgconfiglite
+IF %errorlevel% NEQ 0 (
+  echo Can't install pkgconfiglite
+  exit /b %errorlevel%
+)
+
+echo Installing ninja...
+choco install -y ninja
+IF %errorlevel% NEQ 0 (
+  echo Can't install ninja
+  exit /b %errorlevel%
+)
+
+echo Installing nasm...
+choco install -y nasm
+where nasm
+SET PATH=%PATH%;C:\Program Files\NASM
+IF %errorlevel% NEQ 0 (
+  echo Can't install nasm
+  exit /b %errorlevel%
+)
+
+mkdir third_libs
+cd third_libs
+
+set third_libs=%cd%
+echo %third_libs%
+
+if not exist "zlib" (
+  git clone https://github.com/madler/zlib.git
+  cd zlib
+  git checkout v1.3.1
+  cd contrib\vstudio\vc14
+  msbuild zlibstat.vcxproj /p:Configuration=ReleaseWithoutAsm /p:platform=x64 -p:PlatformToolset=v142
+  cd ..\..\..\..
+) else (
+  echo Using zlib...
+)
+
+if not exist "lz4" (
+  git clone https://github.com/lz4/lz4.git
+  cd lz4
+  git checkout v1.9.4
+  cd build\VS2017\liblz4
+  msbuild liblz4.vcxproj /p:Configuration=Release /p:platform=x64 -p:PlatformToolset=v142
+  cd ..\..\..\..
+) else (
+  echo Using lz4...
+)
+
+if not exist "libsodium" (
+  git clone https://github.com/jedisct1/libsodium
+  cd libsodium
+  git checkout 1.0.18-RELEASE
+  msbuild libsodium.vcxproj /p:Configuration=Release /p:platform=x64 -p:PlatformToolset=v142
+  cd ..
+) else (
+  echo Using libsodium...
+)
+
+if not exist "openssl" (
+  git clone https://github.com/openssl/openssl.git
+  cd openssl
+  git checkout openssl-3.1.4
+  where perl
+  perl Configure VC-WIN64A
+  IF %errorlevel% NEQ 0 (
+    echo Can't configure openssl
+    exit /b %errorlevel%
+  )
+  nmake
+  cd ..
+) else (
+  echo Using openssl...
+)
+
+if not exist "libmicrohttpd" (
+  git clone https://github.com/Karlson2k/libmicrohttpd.git
+  cd libmicrohttpd
+  git checkout v1.0.1
+  cd w32\VS2019
+  msbuild libmicrohttpd.vcxproj /p:Configuration=Release-static /p:platform=x64 -p:PlatformToolset=v142
+  IF %errorlevel% NEQ 0 (
+    echo Can't compile libmicrohttpd
+    exit /b %errorlevel%
+  )
+  cd ../../..
+) else (
+  echo Using libmicrohttpd...
+)
+
+cd ..
+echo Current dir %cd%
+
+mkdir build
+cd build
+cmake -GNinja  -DCMAKE_BUILD_TYPE=Release ^
+-DPORTABLE=1 ^
+-DSODIUM_USE_STATIC_LIBS=1 ^
+-DSODIUM_LIBRARY_RELEASE=%third_libs%\libsodium\Build\Release\x64\libsodium.lib ^
+-DSODIUM_LIBRARY_DEBUG=%third_libs%\libsodium\Build\Release\x64\libsodium.lib ^
+-DSODIUM_INCLUDE_DIR=%third_libs%\libsodium\src\libsodium\include ^
+-DLZ4_FOUND=1 ^
+-DLZ4_INCLUDE_DIRS=%third_libs%\lz4\lib ^
+-DLZ4_LIBRARIES=%third_libs%\lz4\build\VS2017\liblz4\bin\x64_Release\liblz4_static.lib ^
+-DMHD_FOUND=1 ^
+-DMHD_LIBRARY=%third_libs%\libmicrohttpd\w32\VS2019\Output\x64\libmicrohttpd.lib ^
+-DMHD_INCLUDE_DIR=%third_libs%\libmicrohttpd\src\include ^
+-DZLIB_FOUND=1 ^
+-DZLIB_INCLUDE_DIR=%third_libs%\zlib ^
+-DZLIB_LIBRARIES=%third_libs%\zlib\contrib\vstudio\vc14\x64\ZlibStatReleaseWithoutAsm\zlibstat.lib ^
+-DOPENSSL_FOUND=1 ^
+-DOPENSSL_INCLUDE_DIR=%third_libs%\openssl\include ^
+-DOPENSSL_CRYPTO_LIBRARY=%third_libs%\openssl\libcrypto_static.lib ^
+-DCMAKE_CXX_FLAGS="/DTD_WINDOWS=1 /EHsc /bigobj" ..
+
+IF %errorlevel% NEQ 0 (
+  echo Can't configure TON
+  exit /b %errorlevel%
+)
+
+IF "%1"=="-t" (
+ninja storage-daemon storage-daemon-cli blockchain-explorer fift func tolk tonlib tonlibjson  ^
+tonlib-cli validator-engine lite-client pow-miner validator-engine-console generate-random-id ^
+json2tlo dht-server http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork emulator ^
+test-ed25519 test-ed25519-crypto test-bigint test-vm test-fift test-cells test-smartcont test-net ^
+test-tdactor test-tdutils test-tonlib-offline test-adnl test-dht test-rldp test-rldp2 test-catchain ^
+test-fec test-tddb test-db test-validator-session-state test-emulator proxy-liteserver
+IF %errorlevel% NEQ 0 (
+  echo Can't compile TON
+  exit /b %errorlevel%
+)
+) else (
+ninja storage-daemon storage-daemon-cli blockchain-explorer fift func tolk tonlib tonlibjson  ^
+tonlib-cli validator-engine lite-client pow-miner validator-engine-console generate-random-id ^
+json2tlo dht-server http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork emulator proxy-liteserver
+IF %errorlevel% NEQ 0 (
+  echo Can't compile TON
+  exit /b %errorlevel%
+)
+)
+
+copy validator-engine\validator-engine.exe test
+IF %errorlevel% NEQ 0 (
+  echo validator-engine.exe does not exist
+  exit /b %errorlevel%
+)
+
+IF "%1"=="-t" (
+  echo Running tests...
+REM  ctest -C Release --output-on-failure -E "test-catchain|test-actors|test-validator-session-state"
+  ctest -C Release --output-on-failure -E "test-bigint" --timeout 1800
+  IF %errorlevel% NEQ 0 (
+    echo Some tests failed
+    exit /b %errorlevel%
+  )
+)
+
+echo Strip and copy artifacts
+cd ..
+echo where strip
+where strip
+mkdir artifacts
+mkdir artifacts\smartcont
+mkdir artifacts\lib
+
+for %%I in (build\storage\storage-daemon\storage-daemon.exe ^
+  build\storage\storage-daemon\storage-daemon-cli.exe ^
+  build\blockchain-explorer\blockchain-explorer.exe ^
+  build\crypto\fift.exe ^
+  build\crypto\tlbc.exe ^
+  build\crypto\func.exe ^
+  build\tolk\tolk.exe ^
+  build\crypto\create-state.exe ^
+  build\validator-engine-console\validator-engine-console.exe ^
+  build\tonlib\tonlib-cli.exe ^
+  build\tonlib\tonlibjson.dll ^
+  build\http\http-proxy.exe ^
+  build\rldp-http-proxy\rldp-http-proxy.exe ^
+  build\dht-server\dht-server.exe ^
+  build\lite-client\lite-client.exe ^
+  build\validator-engine\validator-engine.exe ^
+  build\utils\generate-random-id.exe ^
+  build\utils\json2tlo.exe ^
+  build\utils\proxy-liteserver.exe ^
+  build\adnl\adnl-proxy.exe ^
+  build\emulator\emulator.dll) do (
+    echo strip -s %%I & copy %%I artifacts\
+    strip -s %%I & copy %%I artifacts\
+)
+
+xcopy /e /k /h /i crypto\smartcont artifacts\smartcont
+xcopy /e /k /h /i crypto\fift\lib artifacts\lib

assembly/native/build-windows-github-2019.bat

@@ -0,0 +1,2 @@
+call "C:\Program Files (x86)\Microsoft Visual Studio\2019\%1\VC\Auxiliary\Build\vcvars64.bat"
+call build-windows-2019.bat -t

assembly/native/build-windows-github.bat

@@ -0,0 +1,2 @@
+call "C:\Program Files\Microsoft Visual Studio\2022\%1\VC\Auxiliary\Build\vcvars64.bat"
+call build-windows.bat -t

assembly/native/build-windows.bat

@@ -0,0 +1,208 @@
+REM execute this script inside elevated (Run as Administrator) console "x64 Native Tools Command Prompt for VS 2022"
+
+echo off
+
+echo Installing chocolatey windows package manager...
+@"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin"
+choco -?
+IF %errorlevel% NEQ 0 (
+  echo Can't install chocolatey
+  exit /b %errorlevel%
+)
+
+choco feature enable -n allowEmptyChecksums
+
+echo Installing pkgconfiglite...
+choco install -y pkgconfiglite
+IF %errorlevel% NEQ 0 (
+  echo Can't install pkgconfiglite
+  exit /b %errorlevel%
+)
+
+echo Installing ninja...
+choco install -y ninja
+IF %errorlevel% NEQ 0 (
+  echo Can't install ninja
+  exit /b %errorlevel%
+)
+
+echo Installing nasm...
+choco install -y nasm
+where nasm
+SET PATH=%PATH%;C:\Program Files\NASM
+IF %errorlevel% NEQ 0 (
+  echo Can't install nasm
+  exit /b %errorlevel%
+)
+
+mkdir third_libs
+cd third_libs
+
+set third_libs=%cd%
+echo %third_libs%
+
+if not exist "zlib" (
+  git clone https://github.com/madler/zlib.git
+  cd zlib
+  git checkout v1.3.1
+  cd contrib\vstudio\vc14
+  msbuild zlibstat.vcxproj /p:Configuration=ReleaseWithoutAsm /p:platform=x64 -p:PlatformToolset=v143
+  cd ..\..\..\..
+) else (
+  echo Using zlib...
+)
+
+if not exist "lz4" (
+  git clone https://github.com/lz4/lz4.git
+  cd lz4
+  git checkout v1.9.4
+  cd build\VS2022\liblz4
+  msbuild liblz4.vcxproj /p:Configuration=Release /p:platform=x64 -p:PlatformToolset=v143
+  cd ..\..\..\..
+) else (
+  echo Using lz4...
+)
+
+if not exist "libsodium" (
+  git clone https://github.com/jedisct1/libsodium
+  cd libsodium
+  git checkout 1.0.18-RELEASE
+  msbuild libsodium.vcxproj /p:Configuration=Release /p:platform=x64 -p:PlatformToolset=v143
+  cd ..
+) else (
+  echo Using libsodium...
+)
+
+if not exist "openssl" (
+  git clone https://github.com/openssl/openssl.git
+  cd openssl
+  git checkout openssl-3.1.4
+  where perl
+  perl Configure VC-WIN64A
+  IF %errorlevel% NEQ 0 (
+    echo Can't configure openssl
+    exit /b %errorlevel%
+  )
+  nmake
+  cd ..
+) else (
+  echo Using openssl...
+)
+
+if not exist "libmicrohttpd" (
+  git clone https://github.com/Karlson2k/libmicrohttpd.git
+  cd libmicrohttpd
+  git checkout v1.0.1
+  cd w32\VS2022
+  msbuild libmicrohttpd.vcxproj /p:Configuration=Release-static /p:platform=x64 -p:PlatformToolset=v143
+  IF %errorlevel% NEQ 0 (
+    echo Can't compile libmicrohttpd
+    exit /b %errorlevel%
+  )
+  cd ../../..
+) else (
+  echo Using libmicrohttpd...
+)
+
+cd ..
+echo Current dir %cd%
+
+mkdir build
+cd build
+cmake -GNinja  -DCMAKE_BUILD_TYPE=Release ^
+-DPORTABLE=1 ^
+-DSODIUM_USE_STATIC_LIBS=1 ^
+-DSODIUM_LIBRARY_RELEASE=%third_libs%\libsodium\Build\Release\x64\libsodium.lib ^
+-DSODIUM_LIBRARY_DEBUG=%third_libs%\libsodium\Build\Release\x64\libsodium.lib ^
+-DSODIUM_INCLUDE_DIR=%third_libs%\libsodium\src\libsodium\include ^
+-DLZ4_FOUND=1 ^
+-DLZ4_INCLUDE_DIRS=%third_libs%\lz4\lib ^
+-DLZ4_LIBRARIES=%third_libs%\lz4\build\VS2022\liblz4\bin\x64_Release\liblz4_static.lib ^
+-DMHD_FOUND=1 ^
+-DMHD_LIBRARY=%third_libs%\libmicrohttpd\w32\VS2022\Output\x64\libmicrohttpd.lib ^
+-DMHD_INCLUDE_DIR=%third_libs%\libmicrohttpd\src\include ^
+-DZLIB_FOUND=1 ^
+-DZLIB_INCLUDE_DIR=%third_libs%\zlib ^
+-DZLIB_LIBRARIES=%third_libs%\zlib\contrib\vstudio\vc14\x64\ZlibStatReleaseWithoutAsm\zlibstat.lib ^
+-DOPENSSL_FOUND=1 ^
+-DOPENSSL_INCLUDE_DIR=%third_libs%\openssl\include ^
+-DOPENSSL_CRYPTO_LIBRARY=%third_libs%\openssl\libcrypto_static.lib ^
+-DCMAKE_CXX_FLAGS="/DTD_WINDOWS=1 /EHsc /bigobj" ..
+
+IF %errorlevel% NEQ 0 (
+  echo Can't configure TON
+  exit /b %errorlevel%
+)
+
+IF "%1"=="-t" (
+ninja storage-daemon storage-daemon-cli blockchain-explorer fift func tolk tonlib tonlibjson  ^
+tonlib-cli validator-engine lite-client pow-miner validator-engine-console generate-random-id ^
+json2tlo dht-server http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork emulator ^
+test-ed25519 test-ed25519-crypto test-bigint test-vm test-fift test-cells test-smartcont test-net ^
+test-tdactor test-tdutils test-tonlib-offline test-adnl test-dht test-rldp test-rldp2 test-catchain ^
+test-fec test-tddb test-db test-validator-session-state test-emulator proxy-liteserver
+IF %errorlevel% NEQ 0 (
+  echo Can't compile TON
+  exit /b %errorlevel%
+)
+) else (
+ninja storage-daemon storage-daemon-cli blockchain-explorer fift func tolk tonlib tonlibjson  ^
+tonlib-cli validator-engine lite-client pow-miner validator-engine-console generate-random-id ^
+json2tlo dht-server http-proxy rldp-http-proxy adnl-proxy create-state create-hardfork emulator proxy-liteserver
+IF %errorlevel% NEQ 0 (
+  echo Can't compile TON
+  exit /b %errorlevel%
+)
+)
+
+copy validator-engine\validator-engine.exe test
+IF %errorlevel% NEQ 0 (
+  echo validator-engine.exe does not exist
+  exit /b %errorlevel%
+)
+
+IF "%1"=="-t" (
+  echo Running tests...
+REM  ctest -C Release --output-on-failure -E "test-catchain|test-actors|test-validator-session-state"
+  ctest -C Release --output-on-failure -E "test-bigint" --timeout 1800
+  IF %errorlevel% NEQ 0 (
+    echo Some tests failed
+    exit /b %errorlevel%
+  )
+)
+
+echo Strip and copy artifacts
+cd ..
+echo where strip
+where strip
+mkdir artifacts
+mkdir artifacts\smartcont
+mkdir artifacts\lib
+
+for %%I in (build\storage\storage-daemon\storage-daemon.exe ^
+  build\storage\storage-daemon\storage-daemon-cli.exe ^
+  build\blockchain-explorer\blockchain-explorer.exe ^
+  build\crypto\fift.exe ^
+  build\crypto\tlbc.exe ^
+  build\crypto\func.exe ^
+  build\tolk\tolk.exe ^
+  build\crypto\create-state.exe ^
+  build\validator-engine-console\validator-engine-console.exe ^
+  build\tonlib\tonlib-cli.exe ^
+  build\tonlib\tonlibjson.dll ^
+  build\http\http-proxy.exe ^
+  build\rldp-http-proxy\rldp-http-proxy.exe ^
+  build\dht-server\dht-server.exe ^
+  build\lite-client\lite-client.exe ^
+  build\validator-engine\validator-engine.exe ^
+  build\utils\generate-random-id.exe ^
+  build\utils\json2tlo.exe ^
+  build\utils\proxy-liteserver.exe ^
+  build\adnl\adnl-proxy.exe ^
+  build\emulator\emulator.dll) do (
+    echo strip -s %%I & copy %%I artifacts\
+    strip -s %%I & copy %%I artifacts\
+)
+
+xcopy /e /k /h /i crypto\smartcont artifacts\smartcont
+xcopy /e /k /h /i crypto\fift\lib artifacts\lib

assembly/nix/build-linux-arm64-nix.sh

@@ -0,0 +1,38 @@
+#/bin/bash
+
+nix-build --version
+test $? -eq 0 || { echo "Nix is not installed!"; exit 1; }
+
+with_tests=false
+
+
+while getopts 't' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    *) break
+       ;;
+  esac
+done
+
+cp assembly/nix/linux-arm64* .
+export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+
+if [ "$with_tests" = true ]; then
+  nix-build linux-arm64-static.nix --arg testing true
+else
+  nix-build linux-arm64-static.nix
+fi
+
+mkdir -p artifacts/lib
+cp ./result/bin/* artifacts/
+test $? -eq 0 || { echo "No artifacts have been built..."; exit 1; }
+chmod +x artifacts/*
+rm -rf result
+
+nix-build linux-arm64-tonlib.nix
+
+cp ./result/lib/libtonlibjson.so.0.5 artifacts/libtonlibjson.so
+cp ./result/lib/libemulator.so artifacts/
+cp ./result/lib/fift/* artifacts/lib/
+cp -r ./result/share/ton/smartcont artifacts/
+chmod -R +x artifacts

assembly/nix/build-linux-x86-64-nix.sh

@@ -0,0 +1,38 @@
+#/bin/bash
+
+nix-build --version
+test $? -eq 0 || { echo "Nix is not installed!"; exit 1; }
+
+with_tests=false
+
+
+while getopts 't' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    *) break
+       ;;
+  esac
+done
+
+cp assembly/nix/linux-x86-64* .
+export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+
+if [ "$with_tests" = true ]; then
+  nix-build linux-x86-64-static.nix --arg testing true
+else
+  nix-build linux-x86-64-static.nix
+fi
+
+mkdir -p artifacts/lib
+cp ./result/bin/* artifacts/
+test $? -eq 0 || { echo "No artifacts have been built..."; exit 1; }
+chmod +x artifacts/*
+rm -rf result
+
+nix-build linux-x86-64-tonlib.nix
+
+cp ./result/lib/libtonlibjson.so.0.5 artifacts/libtonlibjson.so
+cp ./result/lib/libemulator.so artifacts/
+cp ./result/lib/fift/* artifacts/lib/
+cp -r ./result/share/ton/smartcont artifacts/
+chmod -R +x artifacts

assembly/nix/build-macos-nix.sh

@@ -0,0 +1,38 @@
+#/bin/bash
+
+nix-build --version
+test $? -eq 0 || { echo "Nix is not installed!"; exit 1; }
+
+with_tests=false
+
+
+while getopts 't' flag; do
+  case "${flag}" in
+    t) with_tests=true ;;
+    *) break
+       ;;
+  esac
+done
+
+cp assembly/nix/macos-* .
+export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+
+if [ "$with_tests" = true ]; then
+  nix-build macos-static.nix --arg testing true
+else
+  nix-build macos-static.nix
+fi
+
+mkdir -p artifacts/lib
+cp ./result-bin/bin/* artifacts/
+test $? -eq 0 || { echo "No artifacts have been built..."; exit 1; }
+chmod +x artifacts/*
+rm -rf result-bin
+
+nix-build macos-tonlib.nix
+
+cp ./result/lib/libtonlibjson.dylib artifacts/
+cp ./result/lib/libemulator.dylib artifacts/
+cp ./result/lib/fift/* artifacts/lib/
+cp -r ./result/share/ton/smartcont artifacts/
+chmod -R +x artifacts

assembly/nix/flakes/flake.lock

@@ -0,0 +1,94 @@
+{
+  "nodes": {
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1673956053,
+        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1681202837,
+        "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "cfacdce06f30d2b68473a46042957675eebb3401",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs-stable": {
+      "locked": {
+        "lastModified": 1698846319,
+        "narHash": "sha256-4jyW/dqFBVpWFnhl0nvP6EN4lP7/ZqPxYRjl6var0Oc=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "50fc86b75d2744e1ab3837ef74b53f103a9b55a0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-23.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-trunk": {
+      "locked": {
+        "lastModified": 1683098912,
+        "narHash": "sha256-bFHOixPoHZ5y44FvFgpEuZV0UYTQPNDZK/XqeUi1Lbs=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "abc97d3572dec126eba9fec358eb2f359a944683",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "flake-utils": "flake-utils",
+        "nixpkgs-stable": "nixpkgs-stable",
+        "nixpkgs-trunk": "nixpkgs-trunk"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

assembly/nix/flakes/flake.nix

@@ -0,0 +1,158 @@
+{
+  inputs = {
+    nixpkgs-stable.url = "github:nixos/nixpkgs/nixos-23.05";
+    nixpkgs-trunk.url = "github:nixos/nixpkgs";
+    flake-compat = {
+      url = "github:edolstra/flake-compat";
+      flake = false;
+    };
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs-stable, nixpkgs-trunk, flake-compat, flake-utils }:
+    let
+      ton = { host, pkgs ? host, stdenv ? pkgs.stdenv, staticGlibc ? false
+        , staticMusl ? false, staticExternalDeps ? staticGlibc }:
+        with host.lib;
+        stdenv.mkDerivation {
+          pname = "ton";
+          version = "dev";
+
+          src = ./.;
+
+          nativeBuildInputs = with host;
+            [ cmake ninja pkg-config git ] ++
+            optionals stdenv.isLinux [ dpkg rpm createrepo_c pacman ];
+          buildInputs = with pkgs;
+          # at some point nixpkgs' pkgsStatic will build with static glibc
+          # then we can skip these manual overrides
+          # and switch between pkgsStatic and pkgsStatic.pkgsMusl for static glibc and musl builds
+            if !staticExternalDeps then [
+              openssl
+              zlib
+              libmicrohttpd
+              libsodium
+              secp256k1
+            ] else
+              [
+                (openssl.override { static = true; }).dev
+                (zlib.override { shared = false; }).dev
+            ]
+            ++ optionals (!stdenv.isDarwin) [ pkgsStatic.libmicrohttpd.dev pkgsStatic.libsodium.dev secp256k1 ]
+            ++ optionals stdenv.isDarwin [ (libiconv.override { enableStatic = true; enableShared = false; }) ]
+            ++ optionals stdenv.isDarwin (forEach [ libmicrohttpd.dev libsodium.dev secp256k1 gmp.dev nettle.dev (gnutls.override { withP11-kit = false; }).dev libtasn1.dev libidn2.dev libunistring.dev gettext ] (x: x.overrideAttrs(oldAttrs: rec { configureFlags = (oldAttrs.configureFlags or []) ++ [ "--enable-static" "--disable-shared" ]; dontDisableStatic = true; })))
+            ++ optionals staticGlibc [ glibc.static ];
+
+          dontAddStaticConfigureFlags = stdenv.isDarwin;
+
+          cmakeFlags = [ "-DTON_USE_ABSEIL=OFF" "-DNIX=ON" ] ++ optionals staticMusl [
+            "-DCMAKE_CROSSCOMPILING=OFF" # pkgsStatic sets cross
+          ] ++ optionals (staticGlibc || staticMusl) [
+            "-DCMAKE_LINK_SEARCH_START_STATIC=ON"
+            "-DCMAKE_LINK_SEARCH_END_STATIC=ON"
+          ] ++ optionals (stdenv.isDarwin) [
+            "-DCMAKE_CXX_FLAGS=-stdlib=libc++" "-DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=11.7"
+          ];
+
+          LDFLAGS = optional staticExternalDeps (concatStringsSep " " [
+            (optionalString stdenv.cc.isGNU "-static-libgcc")
+            (optionalString stdenv.isDarwin "-framework CoreFoundation")
+            "-static-libstdc++"
+          ]);
+
+          GIT_REVISION = if self ? rev then self.rev else "dirty";
+          GIT_REVISION_DATE = (builtins.concatStringsSep "-" (builtins.match "(.{4})(.{2})(.{2}).*" self.lastModifiedDate)) + " " + (builtins.concatStringsSep ":" (builtins.match "^........(.{2})(.{2})(.{2}).*" self.lastModifiedDate));
+
+          postInstall = ''
+            moveToOutput bin "$bin"
+          '';
+
+          preFixup = optionalString stdenv.isDarwin ''
+            for fn in "$bin"/bin/* "$out"/lib/*.dylib; do
+              echo Fixing libc++ in "$fn"
+              install_name_tool -change "$(otool -L "$fn" | grep libc++.1 | cut -d' ' -f1 | xargs)" libc++.1.dylib "$fn"
+              install_name_tool -change "$(otool -L "$fn" | grep libc++abi.1 | cut -d' ' -f1 | xargs)" libc++abi.dylib "$fn"
+            done
+          '';
+
+          outputs = [ "bin" "out" ];
+        };
+      hostPkgs = system:
+        import nixpkgs-stable {
+          inherit system;
+          overlays = [
+            (self: super: {
+              zchunk = nixpkgs-trunk.legacyPackages.${system}.zchunk;
+            })
+          ];
+        };
+    in with flake-utils.lib;
+    (nixpkgs-stable.lib.recursiveUpdate
+      (eachSystem (with system; [ x86_64-linux aarch64-linux ]) (system:
+        let
+          host = hostPkgs system;
+          # look out for https://github.com/NixOS/nixpkgs/issues/129595 for progress on better infra for this
+          #
+          # nixos 19.09 ships with glibc 2.27
+          # we could also just override glibc source to a particular release
+          # but then we'd need to port patches as well
+          nixos1909 = (import (builtins.fetchTarball {
+            url = "https://channels.nixos.org/nixos-19.09/nixexprs.tar.xz";
+            sha256 = "1vp1h2gkkrckp8dzkqnpcc6xx5lph5d2z46sg2cwzccpr8ay58zy";
+          }) { inherit system; });
+          glibc227 = nixos1909.glibc // { pname = "glibc"; };
+          stdenv227 = let
+            cc = host.wrapCCWith {
+              cc = nixos1909.buildPackages.gcc-unwrapped;
+              libc = glibc227;
+              bintools = host.binutils.override { libc = glibc227; };
+            };
+          in (host.overrideCC host.stdenv cc);
+        in rec {
+          packages = rec {
+            ton-normal = ton { inherit host; };
+            ton-static = ton {
+              inherit host;
+              stdenv = host.makeStatic host.stdenv;
+              staticGlibc = true;
+            };
+            ton-musl =
+              let pkgs = nixpkgs-stable.legacyPackages.${system}.pkgsStatic;
+              in ton {
+                inherit host;
+                inherit pkgs;
+                stdenv =
+                  pkgs.gcc12Stdenv; # doesn't build on aarch64-linux w/default GCC 9
+                staticMusl = true;
+              };
+            ton-oldglibc = (ton {
+              inherit host;
+              stdenv = stdenv227;
+              staticExternalDeps = true;
+            });
+            ton-oldglibc_staticbinaries = host.symlinkJoin {
+              name = "ton";
+              paths = [ ton-musl.bin ton-oldglibc.out ];
+            };
+          };
+          devShells.default =
+            host.mkShell { inputsFrom = [ packages.ton-normal ]; };
+        })) (eachSystem (with system; [ x86_64-darwin aarch64-darwin ]) (system:
+          let host = hostPkgs system;
+          in rec {
+            packages = rec {
+              ton-normal = ton { inherit host; };
+              ton-static = ton {
+                inherit host;
+                stdenv = host.makeStatic host.stdenv;
+                staticExternalDeps = true;
+              };
+              ton-staticbin-dylib = host.symlinkJoin {
+                name = "ton";
+                paths = [ ton-static.bin ton-static.out ];
+              };
+            };
+            devShells.default =
+              host.mkShell { inputsFrom = [ packages.ton-normal ]; };
+          })));
+}

assembly/nix/flakes/shell.nix

@@ -0,0 +1,10 @@
+(import
+  (
+    let lock = builtins.fromJSON (builtins.readFile ./flake.lock); in
+    fetchTarball {
+      url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
+      sha256 = lock.nodes.flake-compat.locked.narHash;
+    }
+  )
+  { src = ./.; }
+).shellNix

assembly/nix/linux-arm64-static.nix

@@ -0,0 +1,62 @@
+# export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+
+{ pkgs ? import <nixpkgs> { system = builtins.currentSystem; }
+, lib ? pkgs.lib
+, stdenv ? pkgs.stdenv
+, testing ? false
+}:
+let
+  staticOptions = pkg: pkg.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--without-shared" "--disable-shared" "--disable-tests" ];
+  });
+
+  secp256k1Static = (staticOptions pkgs.secp256k1);
+  libsodiumStatic = (staticOptions pkgs.libsodium);
+  jemallocStatic = (staticOptions pkgs.jemalloc);
+
+  microhttpdStatic = pkgs.libmicrohttpd.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--enable-static" "--disable-tests" "--disable-benchmark" "--disable-shared" "--disable-https" "--with-pic" ];
+  });
+
+in
+stdenv.mkDerivation {
+  pname = "ton";
+  version = "dev-bin";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs;
+    [  cmake ninja git pkg-config ];
+
+  buildInputs = with pkgs;
+    [
+      (openssl.override { static = true; }).dev
+      microhttpdStatic.dev
+      (zlib.override { shared = false; }).dev
+      (lz4.override { enableStatic = true; enableShared = false; }).dev
+      jemallocStatic
+      secp256k1Static
+      libsodiumStatic.dev
+      glibc.static
+    ];
+
+  cmakeFlags = [
+    "-DTON_USE_ABSEIL=OFF"
+    "-DNIX=ON"
+    "-DBUILD_SHARED_LIBS=OFF"
+    "-DCMAKE_LINK_SEARCH_START_STATIC=ON"
+    "-DCMAKE_LINK_SEARCH_END_STATIC=ON"
+    "-DTON_USE_JEMALLOC=ON"
+  ];
+
+  makeStatic = true;
+  doCheck = testing;
+
+  LDFLAGS = [
+    "-static-libgcc" "-static-libstdc++" "-static"
+  ];
+}

assembly/nix/linux-arm64-tonlib.nix

@@ -0,0 +1,61 @@
+# export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+{
+  pkgs ? import <nixpkgs> { system = builtins.currentSystem; }
+, lib ? pkgs.lib
+, stdenv ? pkgs.stdenv
+}:
+let
+  staticOptions = pkg: pkg.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--without-shared" "--disable-shared" "--disable-tests" ];
+  });
+
+  secp256k1Static = (staticOptions pkgs.secp256k1);
+  libsodiumStatic = (staticOptions pkgs.libsodium);
+
+  microhttpdStatic = pkgs.libmicrohttpd.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--enable-static" "--disable-tests" "--disable-benchmark" "--disable-shared" "--disable-https" "--with-pic" ];
+  });
+in
+pkgs.llvmPackages_16.stdenv.mkDerivation {
+  pname = "ton";
+  version = "dev-lib";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs;
+    [
+      cmake ninja git pkg-config
+    ];
+
+  buildInputs = with pkgs;
+    [
+      (openssl.override { static = true; }).dev
+      microhttpdStatic.dev
+      (zlib.override { shared = false; }).dev
+      (lz4.override { enableStatic = true; enableShared = false; }).dev
+      secp256k1Static
+      libsodiumStatic.dev
+    ];
+
+  dontAddStaticConfigureFlags = false;
+  doCheck = false;
+  doInstallCheck = false;
+
+  cmakeFlags = [
+    "-DTON_USE_ABSEIL=ON"
+    "-DNIX=ON"
+    "-DTON_ONLY_TONLIB=ON"
+  ];
+
+  LDFLAGS = [
+     "-static-libgcc" "-static-libstdc++" "-fPIC" "-fcommon"
+  ];
+
+  ninjaFlags = [
+    "tonlibjson" "emulator"
+  ];
+}

assembly/nix/linux-x86-64-static.nix

@@ -0,0 +1,62 @@
+# export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+
+{ pkgs ? import <nixpkgs> { system = builtins.currentSystem; }
+, lib ? pkgs.lib
+, stdenv ? pkgs.stdenv
+, testing ? false
+}:
+let
+  staticOptions = pkg: pkg.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--without-shared" "--disable-shared" "--disable-tests" ];
+  });
+
+  secp256k1Static = (staticOptions pkgs.secp256k1);
+  libsodiumStatic = (staticOptions pkgs.libsodium);
+  jemallocStatic = (staticOptions pkgs.jemalloc);
+
+  microhttpdStatic = pkgs.libmicrohttpd.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--enable-static" "--disable-tests" "--disable-benchmark" "--disable-shared" "--disable-https" "--with-pic" ];
+  });
+
+in
+stdenv.mkDerivation {
+  pname = "ton";
+  version = "dev-bin";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs;
+    [  cmake ninja git pkg-config ];
+
+  buildInputs = with pkgs;
+    [
+      (openssl.override { static = true; }).dev
+      microhttpdStatic.dev
+      (zlib.override { shared = false; }).dev
+      (lz4.override { enableStatic = true; enableShared = false; }).dev
+      jemallocStatic
+      secp256k1Static
+      libsodiumStatic.dev
+      glibc.static
+    ];
+
+  cmakeFlags = [
+    "-DTON_USE_ABSEIL=OFF"
+    "-DNIX=ON"
+    "-DBUILD_SHARED_LIBS=OFF"
+    "-DCMAKE_LINK_SEARCH_START_STATIC=ON"
+    "-DCMAKE_LINK_SEARCH_END_STATIC=ON"
+    "-DTON_USE_JEMALLOC=ON"
+  ];
+
+  makeStatic = true;
+  doCheck = testing;
+
+  LDFLAGS = [
+    "-static-libgcc" "-static-libstdc++" "-fPIC"
+  ];
+}

assembly/nix/linux-x86-64-tonlib.nix

@@ -0,0 +1,77 @@
+# export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.11.tar.gz
+# copy linux-x86-64-tonlib.nix to git root directory and execute:
+# nix-build linux-x86-64-tonlib.nix
+{
+  pkgs ? import <nixpkgs> { system = builtins.currentSystem; }
+, lib ? pkgs.lib
+, stdenv ? pkgs.stdenv
+}:
+let
+  system = builtins.currentSystem;
+
+  staticOptions = pkg: pkg.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--without-shared" "--disable-shared" "--disable-tests" ];
+  });
+
+  secp256k1Static = (staticOptions pkgs.secp256k1);
+  libsodiumStatic = (staticOptions pkgs.libsodium);
+
+  microhttpdStatic = pkgs.libmicrohttpd.overrideAttrs(oldAttrs: {
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    configureFlags = (oldAttrs.configureFlags or []) ++ [ "--enable-static" "--disable-tests" "--disable-benchmark" "--disable-shared" "--disable-https" "--with-pic" ];
+  });
+
+  nixos1909 = (import (builtins.fetchTarball {
+    url = "https://channels.nixos.org/nixos-19.09/nixexprs.tar.xz";
+    sha256 = "1vp1h2gkkrckp8dzkqnpcc6xx5lph5d2z46sg2cwzccpr8ay58zy";
+  }) { inherit system; });
+  glibc227 = nixos1909.glibc // { pname = "glibc"; };
+  stdenv227 = let
+    cc = pkgs.wrapCCWith {
+      cc = nixos1909.buildPackages.gcc-unwrapped;
+      libc = glibc227;
+      bintools = pkgs.binutils.override { libc = glibc227; };
+    };
+  in (pkgs.overrideCC pkgs.stdenv cc);
+
+in
+stdenv227.mkDerivation {
+  pname = "ton";
+  version = "dev-lib";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs;
+    [ cmake ninja git pkg-config ];
+
+  buildInputs = with pkgs;
+    [
+      (openssl.override { static = true; }).dev
+      microhttpdStatic.dev
+      (zlib.override { shared = false; }).dev
+      (lz4.override { enableStatic = true; enableShared = false; }).dev
+      secp256k1Static
+      libsodiumStatic.dev
+    ];
+
+  dontAddStaticConfigureFlags = false;
+  doCheck = false;
+  doInstallCheck = false;
+
+  cmakeFlags = [
+    "-DTON_USE_ABSEIL=ON"
+    "-DNIX=ON"
+    "-DTON_ONLY_TONLIB=ON"
+  ];
+
+  LDFLAGS = [
+     "-static-libgcc" "-static-libstdc++" "-fPIC"
+  ];
+
+  ninjaFlags = [
+    "tonlibjson" "emulator"
+  ];
+}

assembly/nix/macos-static.nix

@@ -0,0 +1,67 @@
+# export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+
+{ pkgs ? import <nixpkgs> { system = builtins.currentSystem; }
+, lib ? pkgs.lib
+, stdenv ? pkgs.stdenv
+, testing ? false
+}:
+
+pkgs.llvmPackages_14.stdenv.mkDerivation {
+  pname = "ton";
+  version = "dev-bin";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs;
+    [ cmake ninja git pkg-config ];
+
+  buildInputs = with pkgs;
+   lib.forEach [
+        secp256k1 libsodium.dev libmicrohttpd.dev gmp.dev nettle.dev libtasn1.dev libidn2.dev libunistring.dev gettext jemalloc (gnutls.override { withP11-kit = false; }).dev
+      ]
+      (x: x.overrideAttrs(oldAttrs: rec { configureFlags = (oldAttrs.configureFlags or []) ++ [ "--enable-static" "--disable-shared" "--disable-tests" ]; dontDisableStatic = true; }))
+    ++ [
+      darwin.apple_sdk.frameworks.CoreFoundation
+      (openssl.override { static = true; }).dev
+      (zlib.override { shared = false; }).dev
+      (libiconv.override { enableStatic = true; enableShared = false; })
+      (lz4.override { enableStatic = true; enableShared = false; }).dev
+   ];
+
+
+  dontAddStaticConfigureFlags = true;
+  makeStatic = true;
+  doCheck = testing;
+
+  configureFlags = [];
+
+  cmakeFlags = [
+    "-DTON_USE_ABSEIL=OFF"
+    "-DNIX=ON"
+    "-DTON_USE_JEMALLOC=ON"
+    "-DCMAKE_CROSSCOMPILING=OFF"
+    "-DCMAKE_LINK_SEARCH_START_STATIC=ON"
+    "-DCMAKE_LINK_SEARCH_END_STATIC=ON"
+    "-DBUILD_SHARED_LIBS=OFF"
+    "-DCMAKE_CXX_FLAGS=-stdlib=libc++"
+    "-DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=11.3"
+  ];
+
+  LDFLAGS = [
+    "-static-libstdc++"
+    "-framework CoreFoundation"
+  ];
+
+  postInstall = ''
+     moveToOutput bin "$bin"
+  '';
+
+  preFixup = ''
+      for fn in "$bin"/bin/* "$out"/lib/*.dylib; do
+        echo Fixing libc++ in "$fn"
+        install_name_tool -change "$(otool -L "$fn" | grep libc++.1 | cut -d' ' -f1 | xargs)" libc++.1.dylib "$fn"
+        install_name_tool -change "$(otool -L "$fn" | grep libc++abi.1 | cut -d' ' -f1 | xargs)" libc++abi.dylib "$fn"
+      done
+  '';
+  outputs = [ "bin" "out" ];
+}

assembly/nix/macos-tonlib.nix

@@ -0,0 +1,56 @@
+# export NIX_PATH=nixpkgs=https://github.com/nixOS/nixpkgs/archive/23.05.tar.gz
+
+{ pkgs ? import <nixpkgs> { system = builtins.currentSystem; }
+, lib ? pkgs.lib
+, stdenv ? pkgs.stdenv
+}:
+
+pkgs.llvmPackages_14.stdenv.mkDerivation {
+  pname = "ton";
+  version = "dev-lib";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs;
+    [ cmake ninja git pkg-config ];
+
+  buildInputs = with pkgs;
+    lib.forEach [
+      secp256k1 libsodium.dev libmicrohttpd.dev gmp.dev nettle.dev libtasn1.dev libidn2.dev libunistring.dev gettext (gnutls.override { withP11-kit = false; }).dev
+    ] (x: x.overrideAttrs(oldAttrs: rec { configureFlags = (oldAttrs.configureFlags or []) ++ [ "--enable-static" "--disable-shared" "--disable-tests" ]; dontDisableStatic = true; }))
+    ++ [
+      darwin.apple_sdk.frameworks.CoreFoundation
+      (openssl.override { static = true; }).dev
+      (zlib.override { shared = false; }).dev
+      (libiconv.override { enableStatic = true; enableShared = false; })
+      (lz4.override { enableStatic = true; enableShared = false; }).dev
+    ];
+
+  dontAddStaticConfigureFlags = true;
+
+  configureFlags = [];
+
+  cmakeFlags = [
+    "-DTON_USE_ABSEIL=OFF"
+    "-DNIX=ON"
+    "-DCMAKE_CXX_FLAGS=-stdlib=libc++"
+    "-DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=11.3"
+  ];
+
+  LDFLAGS = [
+    "-static-libstdc++"
+    "-framework CoreFoundation"
+  ];
+
+  ninjaFlags = [
+    "tonlibjson" "emulator"
+  ];
+
+  preFixup = ''
+     for fn in $out/bin/* $out/lib/*.dylib; do
+        echo Fixing libc++ in "$fn"
+        install_name_tool -change "$(otool -L "$fn" | grep libc++.1 | cut -d' ' -f1 | xargs)" libc++.1.dylib "$fn"
+        install_name_tool -change "$(otool -L "$fn" | grep libc++abi.1 | cut -d' ' -f1 | xargs)" libc++abi.dylib "$fn"
+     done
+  '';
+}

assembly/wasm/fift-func-wasm-build-ubuntu.sh

@@ -0,0 +1,182 @@
+# Execute these prerequisites first
+# sudo apt update
+# sudo apt install -y build-essential git make cmake ninja-build clang libgflags-dev zlib1g-dev libssl-dev \
+#                    libreadline-dev libmicrohttpd-dev pkg-config libgsl-dev python3 python3-dev python3-pip \
+#                    nodejs libsodium-dev automake libtool libjemalloc-dev
+
+# wget https://apt.llvm.org/llvm.sh
+# chmod +x llvm.sh
+# sudo ./llvm.sh 16 all
+
+with_artifacts=false
+scratch_new=false
+
+while getopts 'af' flag; do
+  case "${flag}" in
+    a) with_artifacts=true ;;
+    f) scratch_new=true ;;
+    *) break
+       ;;
+  esac
+done
+
+export CC=$(which clang-16)
+export CXX=$(which clang++-16)
+export CCACHE_DISABLE=1
+
+echo `pwd`
+if [ "$scratch_new" = true ]; then
+  echo Compiling openssl zlib lz4 emsdk libsodium emsdk ton
+  rm -rf openssl zlib lz4 emsdk libsodium build openssl_em
+fi
+
+
+if [ ! -d "openssl" ]; then
+  git clone https://github.com/openssl/openssl.git
+  cp -r openssl openssl_em
+  cd openssl
+  git checkout openssl-3.1.4
+  ./config
+  make -j16
+  OPENSSL_DIR=`pwd`
+  cd ..
+else
+  OPENSSL_DIR=`pwd`/openssl
+  echo Using compiled openssl at $OPENSSL_DIR
+fi
+
+if [ ! -d "build" ]; then
+  mkdir build
+  cd build
+  cmake -GNinja -DTON_USE_JEMALLOC=ON .. \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DOPENSSL_ROOT_DIR=$OPENSSL_DIR \
+  -DOPENSSL_INCLUDE_DIR=$OPENSSL_DIR/include \
+  -DOPENSSL_CRYPTO_LIBRARY=$OPENSSL_DIR/libcrypto.so
+
+  test $? -eq 0 || { echo "Can't configure TON build"; exit 1; }
+  ninja fift smc-envelope
+  test $? -eq 0 || { echo "Can't compile fift "; exit 1; }
+  rm -rf * .ninja* CMakeCache.txt
+  cd ..
+else
+  echo cleaning build...
+  rm -rf build/* build/.ninja* build/CMakeCache.txt
+fi
+
+if [ ! -d "emsdk" ]; then
+  git clone https://github.com/emscripten-core/emsdk.git
+echo
+  echo Using cloned emsdk
+fi
+
+cd emsdk
+./emsdk install 3.1.19
+./emsdk activate 3.1.19
+EMSDK_DIR=`pwd`
+
+. $EMSDK_DIR/emsdk_env.sh
+export CC=$(which emcc)
+export CXX=$(which em++)
+export CCACHE_DISABLE=1
+
+cd ..
+
+if [ ! -f "openssl_em/openssl_em" ]; then
+  cd openssl_em
+  emconfigure ./Configure linux-generic32 no-shared no-dso no-engine no-unit-test no-tests no-fuzz-afl no-fuzz-libfuzzer
+  sed -i 's/CROSS_COMPILE=.*/CROSS_COMPILE=/g' Makefile
+  sed -i 's/-ldl//g' Makefile
+  sed -i 's/-O3/-Os/g' Makefile
+  emmake make depend
+  emmake make -j16
+  test $? -eq 0 || { echo "Can't compile OpenSSL with emmake "; exit 1; }
+  OPENSSL_DIR=`pwd`
+  touch openssl_em
+  cd ..
+else
+  OPENSSL_DIR=`pwd`/openssl_em
+  echo Using compiled with empscripten openssl at $OPENSSL_DIR
+fi
+
+if [ ! -d "zlib" ]; then
+  git clone https://github.com/madler/zlib.git
+  cd zlib
+  git checkout v1.3.1
+  ZLIB_DIR=`pwd`
+  emconfigure ./configure --static
+  emmake make -j16
+  test $? -eq 0 || { echo "Can't compile zlib with emmake "; exit 1; }
+  cd ..
+else
+  ZLIB_DIR=`pwd`/zlib
+  echo Using compiled zlib with emscripten at $ZLIB_DIR
+fi
+
+if [ ! -d "lz4" ]; then
+  git clone https://github.com/lz4/lz4.git
+  cd lz4
+  git checkout v1.9.4
+  LZ4_DIR=`pwd`
+  emmake make -j16
+  test $? -eq 0 || { echo "Can't compile lz4 with emmake "; exit 1; }
+  cd ..
+else
+  LZ4_DIR=`pwd`/lz4
+  echo Using compiled lz4 with emscripten at $LZ4_DIR
+fi
+
+if [ ! -d "libsodium" ]; then
+  git clone https://github.com/jedisct1/libsodium
+  cd libsodium
+  git checkout 1.0.18-RELEASE
+  SODIUM_DIR=`pwd`
+  emconfigure ./configure --disable-ssp
+  emmake make -j16
+  test $? -eq 0 || { echo "Can't compile libsodium with emmake "; exit 1; }
+  cd ..
+else
+  SODIUM_DIR=`pwd`/libsodium
+  echo Using compiled libsodium with emscripten at $SODIUM_DIR
+fi
+
+cd build
+
+emcmake cmake -DUSE_EMSCRIPTEN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON \
+-DZLIB_FOUND=1 \
+-DZLIB_LIBRARIES=$ZLIB_DIR/libz.a \
+-DZLIB_INCLUDE_DIR=$ZLIB_DIR \
+-DLZ4_FOUND=1 \
+-DLZ4_LIBRARIES=$LZ4_DIR/lib/liblz4.a \
+-DLZ4_INCLUDE_DIRS=$LZ4_DIR/lib \
+-DOPENSSL_FOUND=1 \
+-DOPENSSL_INCLUDE_DIR=$OPENSSL_DIR/include \
+-DOPENSSL_CRYPTO_LIBRARY=$OPENSSL_DIR/libcrypto.a \
+-DCMAKE_TOOLCHAIN_FILE=$EMSDK_DIR/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake \
+-DCMAKE_CXX_FLAGS="-sUSE_ZLIB=1" \
+-DSODIUM_FOUND=1 \
+-DSODIUM_INCLUDE_DIR=$SODIUM_DIR/src/libsodium/include \
+-DSODIUM_USE_STATIC_LIBS=1 \
+-DSODIUM_LIBRARY_RELEASE=$SODIUM_DIR/src/libsodium/.libs/libsodium.a \
+..
+
+test $? -eq 0 || { echo "Can't configure TON with emmake "; exit 1; }
+cp -R ../crypto/smartcont ../crypto/fift/lib crypto
+
+emmake make -j16 funcfiftlib func fift tlbc emulator-emscripten
+
+test $? -eq 0 || { echo "Can't compile TON with emmake "; exit 1; }
+
+if [ "$with_artifacts" = true ]; then
+  echo "Creating artifacts..."
+  cd ..
+  rm -rf artifacts
+  mkdir artifacts
+  ls build/crypto
+  cp build/crypto/fift* artifacts
+  cp build/crypto/func* artifacts
+  cp build/crypto/tlbc* artifacts
+  cp build/emulator/emulator-emscripten* artifacts
+  cp -R crypto/smartcont artifacts
+  cp -R crypto/fift/lib artifacts
+fi

assembly/wasm/intrinsics.fc

@@ -0,0 +1,61 @@
+#pragma allow-post-modification;
+#pragma compute-asm-ltr;
+
+(slice, slice) __tact_load_address(slice cs) inline {
+    slice raw = cs~load_msg_addr();
+    return (cs, raw);
+}
+
+slice __gen_slice1 () asm """
+    B{b5ee9c72410101010005000006abcdefe1e98884} B>boc <s PUSHSLICE
+""";
+
+slice __gen_slice_slice_eb58904b617945cdf4f33042169c462cd36cf1772a2229f06171fd899e920b7f() asm """
+    B{b5ee9c724101010100030000011025086565} B>boc <s PUSHSLICE
+""";
+
+slice __gen_slice3 () asm """
+    B{b5ee9c724101010100030000017888c37a8e} B>boc <s PUSHSLICE
+""";
+
+slice __gen_slice_slice_6694a4a61b0dc7c7d5f63bbd394449f6921de7b2ad9cb() asm """
+    B{b5ee9c724101010100820000ffabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdab} B>boc <s PUSHSLICE
+""";
+
+slice __gen_slice_slice_80b26bab85f37e2bde3795993cdf7402cd42e68eff6187e8388083ce6cfe7c92() asm """
+    B{b5ee9c724101010100030000018a0adc2f9c} B>boc <s PUSHSLICE
+""";
+
+
+(slice,((slice, cell, int, int, slice, slice, int, int, int, int, slice, slice, slice, slice, slice, slice, slice, slice, slice, slice, slice))) IntrinsicsTester_load(slice sc_0) inline {
+    var v'c = sc_0~__tact_load_address();
+    var v'd = sc_0~load_ref();
+    var v'e = sc_0~load_int(257);
+    var v'f = sc_0~load_int(257);
+    slice sc_1 = sc_0~load_ref().begin_parse();
+    var v'g = sc_1~load_ref().begin_parse();
+    var v'h = sc_1~load_ref().begin_parse();
+    var v'i = sc_1~load_int(257);
+    var v'j = sc_1~load_int(257);
+    var v'k = sc_1~load_int(257);
+    slice sc_2 = sc_1~load_ref().begin_parse();
+    var v'l = sc_2~load_int(257);
+    var v'm = sc_2~load_ref().begin_parse();
+    var v'n = sc_2~load_ref().begin_parse();
+    var v'o = sc_2~load_ref().begin_parse();
+    slice sc_3 = sc_2~load_ref().begin_parse();
+    var v'p = sc_3~load_ref().begin_parse();
+    var v'q = sc_3~load_ref().begin_parse();
+    var v'r = sc_3~load_ref().begin_parse();
+    slice sc_4 = sc_3~load_ref().begin_parse();
+    var v's = sc_4~load_ref().begin_parse();
+    var v't = sc_4~load_ref().begin_parse();
+    var v'u = sc_4~load_ref().begin_parse();
+    slice sc_5 = sc_4~load_ref().begin_parse();
+    var v'w = sc_5~load_ref().begin_parse();
+    var v'v = sc_5~load_ref().begin_parse();
+    return (sc_0, (v'c, v'd, v'e, v'f, v'g, v'h, v'i, v'j, v'k, v'l, v'm, v'n, v'o, v'p, v'q, v'r, v's, v't, v'u, v'w, v'v));
+}
+
+() recv_internal(int msg_value, cell in_msg_cell, slice in_msg) impure { }
+

assembly/wasm/stdlib.fc

@@ -0,0 +1,681 @@
+;; Standard library for funC
+;;
+
+{-
+    This file is part of TON FunC Standard Library.
+
+    FunC Standard Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    FunC Standard Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+-}
+
+{-
+  # Tuple manipulation primitives
+  The names and the types are mostly self-explaining.
+  See [polymorhism with forall](https://ton.org/docs/#/func/functions?id=polymorphism-with-forall)
+  for more info on the polymorphic functions.
+
+  Note that currently values of atomic type `tuple` can't be cast to composite tuple type (e.g. `[int, cell]`)
+  and vise versa.
+-}
+
+{-
+  # Lisp-style lists
+
+  Lists can be represented as nested 2-elements tuples.
+  Empty list is conventionally represented as TVM `null` value (it can be obtained by calling [null()]).
+  For example, tuple `(1, (2, (3, null)))` represents list `[1, 2, 3]`. Elements of a list can be of different types.
+-}
+
+;;; Adds an element to the beginning of lisp-style list.
+forall X -> tuple cons(X head, tuple tail) asm "CONS";
+
+;;; Extracts the head and the tail of lisp-style list.
+forall X -> (X, tuple) uncons(tuple list) asm "UNCONS";
+
+;;; Extracts the tail and the head of lisp-style list.
+forall X -> (tuple, X) list_next(tuple list) asm(-> 1 0) "UNCONS";
+
+;;; Returns the head of lisp-style list.
+forall X -> X car(tuple list) asm "CAR";
+
+;;; Returns the tail of lisp-style list.
+tuple cdr(tuple list) asm "CDR";
+
+;;; Creates tuple with zero elements.
+tuple empty_tuple() asm "NIL";
+
+;;; Appends a value `x` to a `Tuple t = (x1, ..., xn)`, but only if the resulting `Tuple t' = (x1, ..., xn, x)`
+;;; is of length at most 255. Otherwise throws a type check exception.
+forall X -> tuple tpush(tuple t, X value) asm "TPUSH";
+forall X -> (tuple, ()) ~tpush(tuple t, X value) asm "TPUSH";
+
+;;; Creates a tuple of length one with given argument as element.
+forall X -> [X] single(X x) asm "SINGLE";
+
+;;; Unpacks a tuple of length one
+forall X -> X unsingle([X] t) asm "UNSINGLE";
+
+;;; Creates a tuple of length two with given arguments as elements.
+forall X, Y -> [X, Y] pair(X x, Y y) asm "PAIR";
+
+;;; Unpacks a tuple of length two
+forall X, Y -> (X, Y) unpair([X, Y] t) asm "UNPAIR";
+
+;;; Creates a tuple of length three with given arguments as elements.
+forall X, Y, Z -> [X, Y, Z] triple(X x, Y y, Z z) asm "TRIPLE";
+
+;;; Unpacks a tuple of length three
+forall X, Y, Z -> (X, Y, Z) untriple([X, Y, Z] t) asm "UNTRIPLE";
+
+;;; Creates a tuple of length four with given arguments as elements.
+forall X, Y, Z, W -> [X, Y, Z, W] tuple4(X x, Y y, Z z, W w) asm "4 TUPLE";
+
+;;; Unpacks a tuple of length four
+forall X, Y, Z, W -> (X, Y, Z, W) untuple4([X, Y, Z, W] t) asm "4 UNTUPLE";
+
+;;; Returns the first element of a tuple (with unknown element types).
+forall X -> X first(tuple t) asm "FIRST";
+
+;;; Returns the second element of a tuple (with unknown element types).
+forall X -> X second(tuple t) asm "SECOND";
+
+;;; Returns the third element of a tuple (with unknown element types).
+forall X -> X third(tuple t) asm "THIRD";
+
+;;; Returns the fourth element of a tuple (with unknown element types).
+forall X -> X fourth(tuple t) asm "3 INDEX";
+
+;;; Returns the first element of a pair tuple.
+forall X, Y -> X pair_first([X, Y] p) asm "FIRST";
+
+;;; Returns the second element of a pair tuple.
+forall X, Y -> Y pair_second([X, Y] p) asm "SECOND";
+
+;;; Returns the first element of a triple tuple.
+forall X, Y, Z -> X triple_first([X, Y, Z] p) asm "FIRST";
+
+;;; Returns the second element of a triple tuple.
+forall X, Y, Z -> Y triple_second([X, Y, Z] p) asm "SECOND";
+
+;;; Returns the third element of a triple tuple.
+forall X, Y, Z -> Z triple_third([X, Y, Z] p) asm "THIRD";
+
+
+;;; Push null element (casted to given type)
+;;; By the TVM type `Null` FunC represents absence of a value of some atomic type.
+;;; So `null` can actually have any atomic type.
+forall X -> X null() asm "PUSHNULL";
+
+;;; Moves a variable [x] to the top of the stack
+forall X -> (X, ()) ~impure_touch(X x) impure asm "NOP";
+
+
+
+;;; Returns the current Unix time as an Integer
+int now() asm "NOW";
+
+;;; Returns the internal address of the current smart contract as a Slice with a `MsgAddressInt`.
+;;; If necessary, it can be parsed further using primitives such as [parse_std_addr].
+slice my_address() asm "MYADDR";
+
+;;; Returns the balance of the smart contract as a tuple consisting of an int
+;;; (balance in nanotoncoins) and a `cell`
+;;; (a dictionary with 32-bit keys representing the balance of "extra currencies")
+;;; at the start of Computation Phase.
+;;; Note that RAW primitives such as [send_raw_message] do not update this field.
+[int, cell] get_balance() asm "BALANCE";
+
+;;; Returns the logical time of the current transaction.
+int cur_lt() asm "LTIME";
+
+;;; Returns the starting logical time of the current block.
+int block_lt() asm "BLOCKLT";
+
+;;; Computes the representation hash of a `cell` [c] and returns it as a 256-bit unsigned integer `x`.
+;;; Useful for signing and checking signatures of arbitrary entities represented by a tree of cells.
+int cell_hash(cell c) asm "HASHCU";
+
+;;; Computes the hash of a `slice s` and returns it as a 256-bit unsigned integer `x`.
+;;; The result is the same as if an ordinary cell containing only data and references from `s` had been created
+;;; and its hash computed by [cell_hash].
+int slice_hash(slice s) asm "HASHSU";
+
+;;; Computes sha256 of the data bits of `slice` [s]. If the bit length of `s` is not divisible by eight,
+;;; throws a cell underflow exception. The hash value is returned as a 256-bit unsigned integer `x`.
+int string_hash(slice s) asm "SHA256U";
+
+{-
+  # Signature checks
+-}
+
+;;; Checks the Ed25519-`signature` of a `hash` (a 256-bit unsigned integer, usually computed as the hash of some data)
+;;; using [public_key] (also represented by a 256-bit unsigned integer).
+;;; The signature must contain at least 512 data bits; only the first 512 bits are used.
+;;; The result is `−1` if the signature is valid, `0` otherwise.
+;;; Note that `CHKSIGNU` creates a 256-bit slice with the hash and calls `CHKSIGNS`.
+;;; That is, if [hash] is computed as the hash of some data, these data are hashed twice,
+;;; the second hashing occurring inside `CHKSIGNS`.
+int check_signature(int hash, slice signature, int public_key) asm "CHKSIGNU";
+
+;;; Checks whether [signature] is a valid Ed25519-signature of the data portion of `slice data` using `public_key`,
+;;; similarly to [check_signature].
+;;; If the bit length of [data] is not divisible by eight, throws a cell underflow exception.
+;;; The verification of Ed25519 signatures is the standard one,
+;;; with sha256 used to reduce [data] to the 256-bit number that is actually signed.
+int check_data_signature(slice data, slice signature, int public_key) asm "CHKSIGNS";
+
+{---
+  # Computation of boc size
+  The primitives below may be useful for computing storage fees of user-provided data.
+-}
+
+;;; Returns `(x, y, z, -1)` or `(null, null, null, 0)`.
+;;; Recursively computes the count of distinct cells `x`, data bits `y`, and cell references `z`
+;;; in the DAG rooted at `cell` [c], effectively returning the total storage used by this DAG taking into account
+;;; the identification of equal cells.
+;;; The values of `x`, `y`, and `z` are computed by a depth-first traversal of this DAG,
+;;; with a hash table of visited cell hashes used to prevent visits of already-visited cells.
+;;; The total count of visited cells `x` cannot exceed non-negative [max_cells];
+;;; otherwise the computation is aborted before visiting the `(max_cells + 1)`-st cell and
+;;; a zero flag is returned to indicate failure. If [c] is `null`, returns `x = y = z = 0`.
+(int, int, int) compute_data_size(cell c, int max_cells) impure asm "CDATASIZE";
+
+;;; Similar to [compute_data_size?], but accepting a `slice` [s] instead of a `cell`.
+;;; The returned value of `x` does not take into account the cell that contains the `slice` [s] itself;
+;;; however, the data bits and the cell references of [s] are accounted for in `y` and `z`.
+(int, int, int) slice_compute_data_size(slice s, int max_cells) impure asm "SDATASIZE";
+
+;;; A non-quiet version of [compute_data_size?] that throws a cell overflow exception (`8`) on failure.
+(int, int, int, int) compute_data_size?(cell c, int max_cells) asm "CDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
+
+;;; A non-quiet version of [slice_compute_data_size?] that throws a cell overflow exception (8) on failure.
+(int, int, int, int) slice_compute_data_size?(cell c, int max_cells) asm "SDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
+
+;;; Throws an exception with exit_code excno if cond is not 0 (commented since implemented in compilator)
+;; () throw_if(int excno, int cond) impure asm "THROWARGIF";
+
+{--
+  # Debug primitives
+  Only works for local TVM execution with debug level verbosity
+-}
+;;; Dumps the stack (at most the top 255 values) and shows the total stack depth.
+() dump_stack() impure asm "DUMPSTK";
+
+{-
+  # Persistent storage save and load
+-}
+
+;;; Returns the persistent contract storage cell. It can be parsed or modified with slice and builder primitives later.
+cell get_data() asm "c4 PUSH";
+
+;;; Sets `cell` [c] as persistent contract data. You can update persistent contract storage with this primitive.
+() set_data(cell c) impure asm "c4 POP";
+
+{-
+  # Continuation primitives
+-}
+;;; Usually `c3` has a continuation initialized by the whole code of the contract. It is used for function calls.
+;;; The primitive returns the current value of `c3`.
+cont get_c3() impure asm "c3 PUSH";
+
+;;; Updates the current value of `c3`. Usually, it is used for updating smart contract code in run-time.
+;;; Note that after execution of this primitive the current code
+;;; (and the stack of recursive function calls) won't change,
+;;; but any other function call will use a function from the new code.
+() set_c3(cont c) impure asm "c3 POP";
+
+;;; Transforms a `slice` [s] into a simple ordinary continuation `c`, with `c.code = s` and an empty stack and savelist.
+cont bless(slice s) impure asm "BLESS";
+
+{---
+  # Gas related primitives
+-}
+
+;;; Sets current gas limit `gl` to its maximal allowed value `gm`, and resets the gas credit `gc` to zero,
+;;; decreasing the value of `gr` by `gc` in the process.
+;;; In other words, the current smart contract agrees to buy some gas to finish the current transaction.
+;;; This action is required to process external messages, which bring no value (hence no gas) with themselves.
+;;;
+;;; For more details check [accept_message effects](https://ton.org/docs/#/smart-contracts/accept).
+() accept_message() impure asm "ACCEPT";
+
+;;; Sets current gas limit `gl` to the minimum of limit and `gm`, and resets the gas credit `gc` to zero.
+;;; If the gas consumed so far (including the present instruction) exceeds the resulting value of `gl`,
+;;; an (unhandled) out of gas exception is thrown before setting new gas limits.
+;;; Notice that [set_gas_limit] with an argument `limit ≥ 2^63 − 1` is equivalent to [accept_message].
+() set_gas_limit(int limit) impure asm "SETGASLIMIT";
+
+;;; Commits the current state of registers `c4` (“persistent data”) and `c5` (“actions”)
+;;; so that the current execution is considered “successful” with the saved values even if an exception
+;;; in Computation Phase is thrown later.
+() commit() impure asm "COMMIT";
+
+;;; Not implemented
+;;; Computes the amount of gas that can be bought for `amount` nanoTONs,
+;;; and sets `gl` accordingly in the same way as [set_gas_limit].
+;;() buy_gas(int amount) impure asm "BUYGAS";
+
+;;; Computes the minimum of two integers [x] and [y].
+int min(int x, int y) asm "MIN";
+
+;;; Computes the maximum of two integers [x] and [y].
+int max(int x, int y) asm "MAX";
+
+;;; Sorts two integers.
+(int, int) minmax(int x, int y) asm "MINMAX";
+
+;;; Computes the absolute value of an integer [x].
+int abs(int x) asm "ABS";
+
+{-
+  # Slice primitives
+
+  It is said that a primitive _loads_ some data,
+  if it returns the data and the remainder of the slice
+  (so it can also be used as [modifying method](https://ton.org/docs/#/func/statements?id=modifying-methods)).
+
+  It is said that a primitive _preloads_ some data, if it returns only the data
+  (it can be used as [non-modifying method](https://ton.org/docs/#/func/statements?id=non-modifying-methods)).
+
+  Unless otherwise stated, loading and preloading primitives read the data from a prefix of the slice.
+-}
+
+
+;;; Converts a `cell` [c] into a `slice`. Notice that [c] must be either an ordinary cell,
+;;; or an exotic cell (see [TVM.pdf](https://ton-blockchain.github.io/docs/tvm.pdf), 3.1.2)
+;;; which is automatically loaded to yield an ordinary cell `c'`, converted into a `slice` afterwards.
+slice begin_parse(cell c) asm "CTOS";
+
+;;; Checks if [s] is empty. If not, throws an exception.
+() end_parse(slice s) impure asm "ENDS";
+
+;;; Loads the first reference from the slice.
+(slice, cell) load_ref(slice s) asm(-> 1 0) "LDREF";
+
+;;; Preloads the first reference from the slice.
+cell preload_ref(slice s) asm "PLDREF";
+
+{- Functions below are commented because are implemented on compilator level for optimisation -}
+
+;;; Loads a signed [len]-bit integer from a slice [s].
+;; (slice, int) ~load_int(slice s, int len) asm(s len -> 1 0) "LDIX";
+
+;;; Loads an unsigned [len]-bit integer from a slice [s].
+;; (slice, int) ~load_uint(slice s, int len) asm( -> 1 0) "LDUX";
+
+;;; Preloads a signed [len]-bit integer from a slice [s].
+;; int preload_int(slice s, int len) asm "PLDIX";
+
+;;; Preloads an unsigned [len]-bit integer from a slice [s].
+;; int preload_uint(slice s, int len) asm "PLDUX";
+
+;;; Loads the first `0 ≤ len ≤ 1023` bits from slice [s] into a separate `slice s''`.
+;; (slice, slice) load_bits(slice s, int len) asm(s len -> 1 0) "LDSLICEX";
+
+;;; Preloads the first `0 ≤ len ≤ 1023` bits from slice [s] into a separate `slice s''`.
+;; slice preload_bits(slice s, int len) asm "PLDSLICEX";
+
+;;; Loads serialized amount of TonCoins (any unsigned integer up to `2^120 - 1`).
+(slice, int) load_grams(slice s) asm(-> 1 0) "LDGRAMS";
+(slice, int) load_coins(slice s) asm(-> 1 0) "LDVARUINT16";
+
+(slice, int) load_varint16(slice s) asm(-> 1 0) "LDVARINT16";
+(slice, int) load_varint32(slice s) asm(-> 1 0) "LDVARINT32";
+(slice, int) load_varuint16(slice s) asm(-> 1 0) "LDVARUINT16";
+(slice, int) load_varuint32(slice s) asm(-> 1 0) "LDVARUINT32";
+
+;;; Returns all but the first `0 ≤ len ≤ 1023` bits of `slice` [s].
+slice skip_bits(slice s, int len) asm "SDSKIPFIRST";
+(slice, ()) ~skip_bits(slice s, int len) asm "SDSKIPFIRST";
+
+;;; Returns the first `0 ≤ len ≤ 1023` bits of `slice` [s].
+slice first_bits(slice s, int len) asm "SDCUTFIRST";
+
+;;; Returns all but the last `0 ≤ len ≤ 1023` bits of `slice` [s].
+slice skip_last_bits(slice s, int len) asm "SDSKIPLAST";
+(slice, ()) ~skip_last_bits(slice s, int len) asm "SDSKIPLAST";
+
+;;; Returns the last `0 ≤ len ≤ 1023` bits of `slice` [s].
+slice slice_last(slice s, int len) asm "SDCUTLAST";
+
+;;; Loads a dictionary `D` (HashMapE) from `slice` [s].
+;;; (returns `null` if `nothing` constructor is used).
+(slice, cell) load_dict(slice s) asm(-> 1 0) "LDDICT";
+
+;;; Preloads a dictionary `D` from `slice` [s].
+cell preload_dict(slice s) asm "PLDDICT";
+
+;;; Loads a dictionary as [load_dict], but returns only the remainder of the slice.
+slice skip_dict(slice s) asm "SKIPDICT";
+(slice, ()) ~skip_dict(slice s) asm "SKIPDICT";
+
+;;; Loads (Maybe ^Cell) from `slice` [s].
+;;; In other words loads 1 bit and if it is true
+;;; loads first ref and return it with slice remainder
+;;; otherwise returns `null` and slice remainder
+(slice, cell) load_maybe_ref(slice s) asm(-> 1 0) "LDOPTREF";
+
+;;; Preloads (Maybe ^Cell) from `slice` [s].
+cell preload_maybe_ref(slice s) asm "PLDOPTREF";
+
+
+;;; Returns the depth of `cell` [c].
+;;; If [c] has no references, then return `0`;
+;;; otherwise the returned value is one plus the maximum of depths of cells referred to from [c].
+;;; If [c] is a `null` instead of a cell, returns zero.
+int cell_depth(cell c) asm "CDEPTH";
+
+
+{-
+  # Slice size primitives
+-}
+
+;;; Returns the number of references in `slice` [s].
+int slice_refs(slice s) asm "SREFS";
+
+;;; Returns the number of data bits in `slice` [s].
+int slice_bits(slice s) asm "SBITS";
+
+;;; Returns both the number of data bits and the number of references in `slice` [s].
+(int, int) slice_bits_refs(slice s) asm "SBITREFS";
+
+;;; Checks whether a `slice` [s] is empty (i.e., contains no bits of data and no cell references).
+int slice_empty?(slice s) asm "SEMPTY";
+
+;;; Checks whether `slice` [s] has no bits of data.
+int slice_data_empty?(slice s) asm "SDEMPTY";
+
+;;; Checks whether `slice` [s] has no references.
+int slice_refs_empty?(slice s) asm "SREMPTY";
+
+;;; Returns the depth of `slice` [s].
+;;; If [s] has no references, then returns `0`;
+;;; otherwise the returned value is one plus the maximum of depths of cells referred to from [s].
+int slice_depth(slice s) asm "SDEPTH";
+
+{-
+  # Builder size primitives
+-}
+
+;;; Returns the number of cell references already stored in `builder` [b]
+int builder_refs(builder b) asm "BREFS";
+
+;;; Returns the number of data bits already stored in `builder` [b].
+int builder_bits(builder b) asm "BBITS";
+
+;;; Returns the depth of `builder` [b].
+;;; If no cell references are stored in [b], then returns 0;
+;;; otherwise the returned value is one plus the maximum of depths of cells referred to from [b].
+int builder_depth(builder b) asm "BDEPTH";
+
+{-
+  # Builder primitives
+  It is said that a primitive _stores_ a value `x` into a builder `b`
+  if it returns a modified version of the builder `b'` with the value `x` stored at the end of it.
+  It can be used as [non-modifying method](https://ton.org/docs/#/func/statements?id=non-modifying-methods).
+
+  All the primitives below first check whether there is enough space in the `builder`,
+  and only then check the range of the value being serialized.
+-}
+
+;;; Creates a new empty `builder`.
+builder begin_cell() asm "NEWC";
+
+;;; Converts a `builder` into an ordinary `cell`.
+cell end_cell(builder b) asm "ENDC";
+
+;;; Stores a reference to `cell` [c] into `builder` [b].
+builder store_ref(builder b, cell c) asm(c b) "STREF";
+
+;;; Stores an unsigned [len]-bit integer `x` into `b` for `0 ≤ len ≤ 256`.
+;; builder store_uint(builder b, int x, int len) asm(x b len) "STUX";
+
+;;; Stores a signed [len]-bit integer `x` into `b` for` 0 ≤ len ≤ 257`.
+;; builder store_int(builder b, int x, int len) asm(x b len) "STIX";
+
+
+;;; Stores `slice` [s] into `builder` [b]
+builder store_slice(builder b, slice s) asm "STSLICER";
+
+;;; Stores (serializes) an integer [x] in the range `0..2^120 − 1` into `builder` [b].
+;;; The serialization of [x] consists of a 4-bit unsigned big-endian integer `l`,
+;;; which is the smallest integer `l ≥ 0`, such that `x < 2^8l`,
+;;; followed by an `8l`-bit unsigned big-endian representation of [x].
+;;; If [x] does not belong to the supported range, a range check exception is thrown.
+;;;
+;;; Store amounts of TonCoins to the builder as VarUInteger 16
+builder store_grams(builder b, int x) asm "STGRAMS";
+builder store_coins(builder b, int x) asm "STVARUINT16";
+
+builder store_varint16(builder b, int x) asm "STVARINT16";
+builder store_varint32(builder b, int x) asm "STVARINT32";
+builder store_varuint16(builder b, int x) asm "STVARUINT16";
+builder store_varuint32(builder b, int x) asm "STVARUINT32";
+
+;;; Stores dictionary `D` represented by `cell` [c] or `null` into `builder` [b].
+;;; In other words, stores a `1`-bit and a reference to [c] if [c] is not `null` and `0`-bit otherwise.
+builder store_dict(builder b, cell c) asm(c b) "STDICT";
+
+;;; Stores (Maybe ^Cell) to builder:
+;;; if cell is null store 1 zero bit
+;;; otherwise store 1 true bit and ref to cell
+builder store_maybe_ref(builder b, cell c) asm(c b) "STOPTREF";
+
+
+{-
+  # Address manipulation primitives
+  The address manipulation primitives listed below serialize and deserialize values according to the following TL-B scheme:
+  ```TL-B
+  addr_none$00 = MsgAddressExt;
+  addr_extern$01 len:(## 8) external_address:(bits len)
+               = MsgAddressExt;
+  anycast_info$_ depth:(#<= 30) { depth >= 1 }
+    rewrite_pfx:(bits depth) = Anycast;
+  addr_std$10 anycast:(Maybe Anycast)
+    workchain_id:int8 address:bits256 = MsgAddressInt;
+  addr_var$11 anycast:(Maybe Anycast) addr_len:(## 9)
+    workchain_id:int32 address:(bits addr_len) = MsgAddressInt;
+  _ _:MsgAddressInt = MsgAddress;
+  _ _:MsgAddressExt = MsgAddress;
+
+  int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
+    src:MsgAddress dest:MsgAddressInt
+    value:CurrencyCollection ihr_fee:Grams fwd_fee:Grams
+    created_lt:uint64 created_at:uint32 = CommonMsgInfoRelaxed;
+  ext_out_msg_info$11 src:MsgAddress dest:MsgAddressExt
+    created_lt:uint64 created_at:uint32 = CommonMsgInfoRelaxed;
+  ```
+  A deserialized `MsgAddress` is represented by a tuple `t` as follows:
+
+  - `addr_none` is represented by `t = (0)`,
+    i.e., a tuple containing exactly one integer equal to zero.
+  - `addr_extern` is represented by `t = (1, s)`,
+    where slice `s` contains the field `external_address`. In other words, `
+    t` is a pair (a tuple consisting of two entries), containing an integer equal to one and slice `s`.
+  - `addr_std` is represented by `t = (2, u, x, s)`,
+    where `u` is either a `null` (if `anycast` is absent) or a slice `s'` containing `rewrite_pfx` (if anycast is present).
+    Next, integer `x` is the `workchain_id`, and slice `s` contains the address.
+  - `addr_var` is represented by `t = (3, u, x, s)`,
+    where `u`, `x`, and `s` have the same meaning as for `addr_std`.
+-}
+
+;;; Loads from slice [s] the only prefix that is a valid `MsgAddress`,
+;;; and returns both this prefix `s'` and the remainder `s''` of [s] as slices.
+(slice, slice) load_msg_addr(slice s) asm(-> 1 0) "LDMSGADDR";
+
+;;; Decomposes slice [s] containing a valid `MsgAddress` into a `tuple t` with separate fields of this `MsgAddress`.
+;;; If [s] is not a valid `MsgAddress`, a cell deserialization exception is thrown.
+tuple parse_addr(slice s) asm "PARSEMSGADDR";
+
+;;; Parses slice [s] containing a valid `MsgAddressInt` (usually a `msg_addr_std`),
+;;; applies rewriting from the anycast (if present) to the same-length prefix of the address,
+;;; and returns both the workchain and the 256-bit address as integers.
+;;; If the address is not 256-bit, or if [s] is not a valid serialization of `MsgAddressInt`,
+;;; throws a cell deserialization exception.
+(int, int) parse_std_addr(slice s) asm "REWRITESTDADDR";
+
+;;; A variant of [parse_std_addr] that returns the (rewritten) address as a slice [s],
+;;; even if it is not exactly 256 bit long (represented by a `msg_addr_var`).
+(int, slice) parse_var_addr(slice s) asm "REWRITEVARADDR";
+
+{-
+  # Dictionary primitives
+-}
+
+
+;;; Sets the value associated with [key_len]-bit key signed index in dictionary [dict] to [value] (cell),
+;;; and returns the resulting dictionary.
+cell idict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETREF";
+(cell, ()) ~idict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETREF";
+
+;;; Sets the value associated with [key_len]-bit key unsigned index in dictionary [dict] to [value] (cell),
+;;; and returns the resulting dictionary.
+cell udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF";
+(cell, ()) ~udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF";
+
+cell idict_get_ref(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGETOPTREF";
+(cell, int) idict_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGETREF" "NULLSWAPIFNOT";
+(cell, int) udict_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUGETREF" "NULLSWAPIFNOT";
+(cell, cell) idict_set_get_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETGETOPTREF";
+(cell, cell) udict_set_get_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETGETOPTREF";
+(cell, int) idict_delete?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDEL";
+(cell, int) udict_delete?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDEL";
+(slice, int) idict_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGET" "NULLSWAPIFNOT";
+(slice, int) udict_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUGET" "NULLSWAPIFNOT";
+(cell, slice, int) idict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDELGET" "NULLSWAPIFNOT";
+(cell, slice, int) udict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDELGET" "NULLSWAPIFNOT";
+(cell, (slice, int)) ~idict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDELGET" "NULLSWAPIFNOT";
+(cell, (slice, int)) ~udict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDELGET" "NULLSWAPIFNOT";
+(cell, cell, int) idict_delete_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDELGETREF" "NULLSWAPIFNOT";
+(cell, cell, int) udict_delete_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDELGETREF" "NULLSWAPIFNOT";
+(cell, (cell, int)) ~idict_delete_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDELGETREF" "NULLSWAPIFNOT";
+(cell, (cell, int)) ~udict_delete_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDELGETREF" "NULLSWAPIFNOT";
+cell udict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUSET";
+(cell, ()) ~udict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUSET";
+cell idict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTISET";
+(cell, ()) ~idict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTISET";
+cell dict_set(cell dict, int key_len, slice index, slice value) asm(value index dict key_len) "DICTSET";
+(cell, ()) ~dict_set(cell dict, int key_len, slice index, slice value) asm(value index dict key_len) "DICTSET";
+(cell, int) udict_add?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUADD";
+(cell, int) udict_replace?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUREPLACE";
+(cell, int) udict_replace_ref?(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUREPLACEREF";
+(cell, slice, int) udict_replaceget?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUREPLACEGET" "NULLSWAPIFNOT";
+(cell, cell, int) udict_replaceget_ref?(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUREPLACEGETREF" "NULLSWAPIFNOT";
+(cell, (slice, int)) ~udict_replaceget?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUREPLACEGET" "NULLSWAPIFNOT";
+(cell, (cell, int)) ~udict_replaceget_ref?(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUREPLACEGETREF" "NULLSWAPIFNOT";
+(cell, int) idict_add?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTIADD";
+(cell, int) idict_replace?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTIREPLACE";
+(cell, int) idict_replace_ref?(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTIREPLACEREF";
+(cell, slice, int) idict_replaceget?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTIREPLACEGET" "NULLSWAPIFNOT";
+(cell, cell, int) idict_replaceget_ref?(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTIREPLACEGETREF" "NULLSWAPIFNOT";
+(cell, (slice, int)) ~idict_replaceget?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTIREPLACEGET" "NULLSWAPIFNOT";
+(cell, (cell, int)) ~idict_replaceget_ref?(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTIREPLACEGETREF" "NULLSWAPIFNOT";
+cell udict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUSETB";
+(cell, ()) ~udict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUSETB";
+cell idict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTISETB";
+(cell, ()) ~idict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTISETB";
+cell dict_set_builder(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTSETB";
+(cell, ()) ~dict_set_builder(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTSETB";
+(cell, int) dict_replace_builder?(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTREPLACEB";
+(cell, builder, int) dict_replaceget_builder?(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTREPLACEGETB" "NULLSWAPIFNOT";
+(cell, slice, int) dict_replaceget?(cell dict, int key_len, slice index, slice value) asm(value index dict key_len) "DICTREPLACEGET" "NULLSWAPIFNOT";
+(cell, (builder, int)) ~dict_replaceget_builder?(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTREPLACEGETB" "NULLSWAPIFNOT";
+(cell, (slice, int)) ~dict_replaceget?(cell dict, int key_len, slice index, slice value) asm(value index dict key_len) "DICTREPLACEGET" "NULLSWAPIFNOT";
+(cell, int) udict_add_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUADDB";
+(cell, int) udict_replace_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUREPLACEB";
+(cell, builder, int) udict_replaceget_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUREPLACEGETB" "NULLSWAPIFNOT";
+(cell, (builder, int)) ~udict_replaceget_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUREPLACEGETB" "NULLSWAPIFNOT";
+(cell, int) idict_add_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTIADDB";
+(cell, int) idict_replace_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTIREPLACEB";
+(cell, builder, int) idict_replaceget_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTIREPLACEGETB" "NULLSWAPIFNOT";
+(cell, (builder, int)) ~idict_replaceget_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTIREPLACEGETB" "NULLSWAPIFNOT";
+(cell, int, slice, int) udict_delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMIN" "NULLSWAPIFNOT2";
+(cell, (int, slice, int)) ~udict::delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMIN" "NULLSWAPIFNOT2";
+(cell, int, slice, int) idict_delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMIN" "NULLSWAPIFNOT2";
+(cell, (int, slice, int)) ~idict::delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMIN" "NULLSWAPIFNOT2";
+(cell, slice, slice, int) dict_delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMIN" "NULLSWAPIFNOT2";
+(cell, (slice, slice, int)) ~dict::delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMIN" "NULLSWAPIFNOT2";
+(cell, int, slice, int) udict_delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMAX" "NULLSWAPIFNOT2";
+(cell, (int, slice, int)) ~udict::delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMAX" "NULLSWAPIFNOT2";
+(cell, int, slice, int) idict_delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMAX" "NULLSWAPIFNOT2";
+(cell, (int, slice, int)) ~idict::delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMAX" "NULLSWAPIFNOT2";
+(cell, slice, slice, int) dict_delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMAX" "NULLSWAPIFNOT2";
+(cell, (slice, slice, int)) ~dict::delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMAX" "NULLSWAPIFNOT2";
+(int, slice, int) udict_get_min?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMIN" "NULLSWAPIFNOT2";
+(int, slice, int) udict_get_max?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMAX" "NULLSWAPIFNOT2";
+(int, cell, int) udict_get_min_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMINREF" "NULLSWAPIFNOT2";
+(int, cell, int) udict_get_max_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMAXREF" "NULLSWAPIFNOT2";
+(int, slice, int) idict_get_min?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMIN" "NULLSWAPIFNOT2";
+(int, slice, int) idict_get_max?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMAX" "NULLSWAPIFNOT2";
+(int, cell, int) idict_get_min_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMINREF" "NULLSWAPIFNOT2";
+(int, cell, int) idict_get_max_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMAXREF" "NULLSWAPIFNOT2";
+(int, slice, int) udict_get_next?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETNEXT" "NULLSWAPIFNOT2";
+(int, slice, int) udict_get_nexteq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETNEXTEQ" "NULLSWAPIFNOT2";
+(int, slice, int) udict_get_prev?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETPREV" "NULLSWAPIFNOT2";
+(int, slice, int) udict_get_preveq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETPREVEQ" "NULLSWAPIFNOT2";
+(int, slice, int) idict_get_next?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETNEXT" "NULLSWAPIFNOT2";
+(int, slice, int) idict_get_nexteq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETNEXTEQ" "NULLSWAPIFNOT2";
+(int, slice, int) idict_get_prev?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETPREV" "NULLSWAPIFNOT2";
+(int, slice, int) idict_get_preveq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETPREVEQ" "NULLSWAPIFNOT2";
+
+;;; Creates an empty dictionary, which is actually a null value. Equivalent to PUSHNULL
+cell new_dict() asm "NEWDICT";
+;;; Checks whether a dictionary is empty. Equivalent to cell_null?.
+int dict_empty?(cell c) asm "DICTEMPTY";
+
+
+{- Prefix dictionary primitives -}
+(slice, slice, slice, int) pfxdict_get?(cell dict, int key_len, slice key) asm(key dict key_len) "PFXDICTGETQ" "NULLSWAPIFNOT2";
+(cell, int) pfxdict_set?(cell dict, int key_len, slice key, slice value) asm(value key dict key_len) "PFXDICTSET";
+(cell, int) pfxdict_delete?(cell dict, int key_len, slice key) asm(key dict key_len) "PFXDICTDEL";
+
+;;; Returns the value of the global configuration parameter with integer index `i` as a `cell` or `null` value.
+cell config_param(int x) asm "CONFIGOPTPARAM";
+;;; Checks whether c is a null. Note, that FunC also has polymorphic null? built-in.
+int cell_null?(cell c) asm "ISNULL";
+
+;;; Creates an output action which would reserve exactly amount nanotoncoins (if mode = 0), at most amount nanotoncoins (if mode = 2), or all but amount nanotoncoins (if mode = 1 or mode = 3), from the remaining balance of the account. It is roughly equivalent to creating an outbound message carrying amount nanotoncoins (or b − amount nanotoncoins, where b is the remaining balance) to oneself, so that the subsequent output actions would not be able to spend more money than the remainder. Bit +2 in mode means that the external action does not fail if the specified amount cannot be reserved; instead, all remaining balance is reserved. Bit +8 in mode means `amount <- -amount` before performing any further actions. Bit +4 in mode means that amount is increased by the original balance of the current account (before the compute phase), including all extra currencies, before performing any other checks and actions. Currently, amount must be a non-negative integer, and mode must be in the range 0..15.
+() raw_reserve(int amount, int mode) impure asm "RAWRESERVE";
+;;; Similar to raw_reserve, but also accepts a dictionary extra_amount (represented by a cell or null) with extra currencies. In this way currencies other than TonCoin can be reserved.
+() raw_reserve_extra(int amount, cell extra_amount, int mode) impure asm "RAWRESERVEX";
+;;; Sends a raw message contained in msg, which should contain a correctly serialized object Message X, with the only exception that the source address is allowed to have dummy value addr_none (to be automatically replaced with the current smart contract address), and ihr_fee, fwd_fee, created_lt and created_at fields can have arbitrary values (to be rewritten with correct values during the action phase of the current transaction). Integer parameter mode contains the flags. Currently mode = 0 is used for ordinary messages; mode = 128 is used for messages that are to carry all the remaining balance of the current smart contract (instead of the value originally indicated in the message); mode = 64 is used for messages that carry all the remaining value of the inbound message in addition to the value initially indicated in the new message (if bit 0 is not set, the gas fees are deducted from this amount); mode' = mode + 1 means that the sender wants to pay transfer fees separately; mode' = mode + 2 means that any errors arising while processing this message during the action phase should be ignored. Finally, mode' = mode + 32 means that the current account must be destroyed if its resulting balance is zero. This flag is usually employed together with +128.
+() send_raw_message(cell msg, int mode) impure asm "SENDRAWMSG";
+;;; Creates an output action that would change this smart contract code to that given by cell new_code. Notice that this change will take effect only after the successful termination of the current run of the smart contract
+() set_code(cell new_code) impure asm "SETCODE";
+
+;;; Generates a new pseudo-random unsigned 256-bit integer x. The algorithm is as follows: if r is the old value of the random seed, considered as a 32-byte array (by constructing the big-endian representation of an unsigned 256-bit integer), then its sha512(r) is computed; the first 32 bytes of this hash are stored as the new value r' of the random seed, and the remaining 32 bytes are returned as the next random value x.
+int random() impure asm "RANDU256";
+;;; Generates a new pseudo-random integer z in the range 0..range−1 (or range..−1, if range < 0). More precisely, an unsigned random value x is generated as in random; then z := x * range / 2^256 is computed.
+int rand(int range) impure asm "RAND";
+;;; Returns the current random seed as an unsigned 256-bit Integer.
+int get_seed() impure asm "RANDSEED";
+;;; Sets the random seed to unsigned 256-bit seed.
+() set_seed(int x) impure asm "SETRAND";
+;;; Mixes unsigned 256-bit integer x into the random seed r by setting the random seed to sha256 of the concatenation of two 32-byte strings: the first with the big-endian representation of the old seed r, and the second with the big-endian representation of x.
+() randomize(int x) impure asm "ADDRAND";
+;;; Equivalent to randomize(cur_lt());.
+() randomize_lt() impure asm "LTIME" "ADDRAND";
+
+;;; Checks whether the data parts of two slices coinside
+int equal_slices_bits(slice a, slice b) asm "SDEQ";
+;;; Checks whether b is a null. Note, that FunC also has polymorphic null? built-in.
+int builder_null?(builder b) asm "ISNULL";
+;;; Concatenates two builders
+builder store_builder(builder to, builder from) asm "STBR";
+
+;; CUSTOM:
+
+;; TVM UPGRADE 2023-07 https://docs.ton.org/learn/tvm-instructions/tvm-upgrade-2023-07
+;; In mainnet since 20 Dec 2023 https://t.me/tonblockchain/226
+
+;;; Retrieves code of smart-contract from c7
+
+cell my_code() asm "MYCODE";

blockchain-explorer/CMakeLists.txt

@@ -1,22 +1,42 @@
-cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
 
+option(NIX "Use \"ON\" for a static build." OFF)
 
-find_package(MHD)
-
-if (MHD_FOUND)
-
-  set(BLOCHAIN_EXPLORER_SOURCE 
+set(BLOCHAIN_EXPLORER_SOURCE
     blockchain-explorer.cpp
     blockchain-explorer.hpp
     blockchain-explorer-http.cpp
     blockchain-explorer-http.hpp
     blockchain-explorer-query.cpp
     blockchain-explorer-query.hpp
-    )
+)
 
-  add_executable(blockchain-explorer ${BLOCHAIN_EXPLORER_SOURCE})
-  target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIRS})
-  target_link_libraries(blockchain-explorer tdutils tdactor adnllite tl_lite_api tl-lite-utils
-    ton_crypto ton_block ${MHD_LIBRARY})
+add_executable(blockchain-explorer ${BLOCHAIN_EXPLORER_SOURCE})
 
+if (NIX)
+  if (MHD_FOUND)
+    target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIR})
+    target_link_libraries(blockchain-explorer tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ${MHD_LIBRARY})
+  else()
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(MHD libmicrohttpd)
+    target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIR} ${MHD_STATIC_INCLUDE_DIRS})
+    target_link_libraries(blockchain-explorer tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ${MHD_LIBRARIES} ${MHD_STATIC_LIBRARIES})
+  endif()
+else()
+  if (MHD_FOUND)
+    target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIR})
+    target_link_libraries(blockchain-explorer tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ${MHD_LIBRARY})
+  else()
+    find_package(MHD)
+    target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIR})
+    target_link_libraries(blockchain-explorer tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ${MHD_LIBRARY})
+  endif()
 endif()
+
+target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIR})
+target_link_libraries(blockchain-explorer tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ${MHD_LIBRARY})
+target_link_libraries(blockchain-explorer lite-client-common)
+
+install(TARGETS blockchain-explorer RUNTIME DESTINATION bin)
+

blockchain-explorer/blockchain-explorer-http.cpp

@@ -35,9 +35,38 @@
 #include "vm/cells/MerkleProof.h"
 #include "block/mc-config.h"
 #include "ton/ton-shard.h"
+#include "td/utils/date.h"
 
 bool local_scripts{false};
 
+static std::string time_to_human(unsigned ts) {
+  td::StringBuilder sb;
+  sb << date::format("%F %T",
+                     std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>{std::chrono::seconds(ts)})
+     << ", ";
+  auto now = (unsigned)td::Clocks::system();
+  bool past = now >= ts;
+  unsigned x = past ? now - ts : ts - now;
+  if (!past) {
+    sb << "in ";
+  }
+  if (x < 60) {
+    sb << x << "s";
+  } else if (x < 3600) {
+    sb << x / 60 << "m " << x % 60 << "s";
+  } else if (x < 3600 * 24) {
+    x /= 60;
+    sb << x / 60 << "h " << x % 60 << "m";
+  } else {
+    x /= 3600;
+    sb << x / 24 << "d " << x % 24 << "h";
+  }
+  if (past) {
+    sb << " ago";
+  }
+  return sb.as_cslice().str();
+}
+
 HttpAnswer& HttpAnswer::operator<<(AddressCell addr_c) {
   ton::WorkchainId wc;
   ton::StdSmcAddress addr;
@@ -84,7 +113,7 @@ HttpAnswer& HttpAnswer::operator<<(MessageCell msg) {
             << "<tr><th>source</th><td>" << AddressCell{info.src} << "</td></tr>\n"
             << "<tr><th>destination</th><td>NONE</td></tr>\n"
             << "<tr><th>lt</th><td>" << info.created_lt << "</td></tr>\n"
-            << "<tr><th>time</th><td>" << info.created_at << "</td></tr>\n";
+            << "<tr><th>time</th><td>" << info.created_at << " (" << time_to_human(info.created_at) << ")</td></tr>\n";
       break;
     }
     case block::gen::CommonMsgInfo::int_msg_info: {
@@ -93,9 +122,8 @@ HttpAnswer& HttpAnswer::operator<<(MessageCell msg) {
         abort("cannot unpack internal message");
         return *this;
       }
-      td::RefInt256 value;
-      td::Ref<vm::Cell> extra;
-      if (!block::unpack_CurrencyCollection(info.value, value, extra)) {
+      block::CurrencyCollection currency_collection;
+      if (!currency_collection.unpack(info.value)) {
         abort("cannot unpack message value");
         return *this;
       }
@@ -103,8 +131,8 @@ HttpAnswer& HttpAnswer::operator<<(MessageCell msg) {
             << "<tr><th>source</th><td>" << AddressCell{info.src} << "</td></tr>\n"
             << "<tr><th>destination</th><td>" << AddressCell{info.dest} << "</td></tr>\n"
             << "<tr><th>lt</th><td>" << info.created_lt << "</td></tr>\n"
-            << "<tr><th>time</th><td>" << info.created_at << "</td></tr>\n"
-            << "<tr><th>value</th><td>" << value << "</td></tr>\n";
+            << "<tr><th>time</th><td>" << info.created_at << " (" << time_to_human(info.created_at) << ")</td></tr>\n"
+            << "<tr><th>value</th><td>" << currency_collection.to_str()<< "</td></tr>\n";
       break;
     }
     default:
@@ -277,7 +305,7 @@ HttpAnswer& HttpAnswer::operator<<(TransactionCell trans_c) {
         << "<tr><th>account</th><td>" << trans_c.addr.rserialize(true) << "</td></tr>"
         << "<tr><th>hash</th><td>" << trans_c.root->get_hash().to_hex() << "</td></tr>\n"
         << "<tr><th>lt</th><td>" << trans.lt << "</td></tr>\n"
-        << "<tr><th>time</th><td>" << trans.now << "</td></tr>\n"
+        << "<tr><th>time</th><td>" << trans.now << " (" << time_to_human(trans.now) << ")</td></tr>\n"
         << "<tr><th>out messages</th><td>";
   vm::Dictionary dict{trans.r1.out_msgs, 15};
   for (td::int32 i = 0; i < trans.outmsg_cnt; i++) {
@@ -336,6 +364,7 @@ HttpAnswer& HttpAnswer::operator<<(AccountCell acc_c) {
   ton::LogicalTime last_trans_lt = 0;
   ton::Bits256 last_trans_hash;
   last_trans_hash.set_zero();
+  block::CurrencyCollection balance = block::CurrencyCollection::zero();
   try {
     auto state_root = vm::MerkleProof::virtualize(acc_c.q_roots[1], 1);
     if (state_root.is_null()) {
@@ -368,6 +397,20 @@ HttpAnswer& HttpAnswer::operator<<(AccountCell acc_c) {
       }
       last_trans_hash = acc_info.last_trans_hash;
       last_trans_lt = acc_info.last_trans_lt;
+      block::gen::Account::Record_account acc;
+      block::gen::AccountStorage::Record storage_rec;
+      if (!tlb::unpack_cell(acc_c.root, acc)) {
+        abort("cannot unpack Account");
+        return *this;
+      }
+      if (!tlb::csr_unpack(acc.storage, storage_rec)) {
+        abort("cannot unpack AccountStorage");
+        return *this;
+      }
+      if (!balance.unpack(storage_rec.balance)) {
+        abort("cannot unpack account balance");
+        return *this;
+      }
     } else if (acc_c.root.not_null()) {
       abort(PSTRING() << "account state proof shows that account state for " << acc_c.addr.workchain << ":"
                       << acc_c.addr.addr.to_hex() << " must be empty, but it is not");
@@ -405,6 +448,7 @@ HttpAnswer& HttpAnswer::operator<<(AccountCell acc_c) {
   *this << "<tr><th>workchain</th><td>" << acc_c.addr.workchain << "</td></tr>";
   *this << "<tr><th>account hex</th><td>" << acc_c.addr.addr.to_hex() << "</td></tr>";
   *this << "<tr><th>account</th><td>" << acc_c.addr.rserialize(true) << "</td></tr>";
+  *this << "<tr><th>balance</th><td>" << balance.to_str() << "</td></tr>";
   if (last_trans_lt > 0) {
     *this << "<tr><th>last transaction</th><td>"
           << "<a href=\"" << TransactionLink{acc_c.addr, last_trans_lt, last_trans_hash} << "\">lt=" << last_trans_lt
@@ -456,7 +500,7 @@ HttpAnswer& HttpAnswer::operator<<(BlockHeaderCell head_c) {
           << "<tr><th>block</th><td>" << block_id.id.to_str() << "</td></tr>\n"
           << "<tr><th>roothash</th><td>" << block_id.root_hash.to_hex() << "</td></tr>\n"
           << "<tr><th>filehash</th><td>" << block_id.file_hash.to_hex() << "</td></tr>\n"
-          << "<tr><th>time</th><td>" << info.gen_utime << "</td></tr>\n"
+          << "<tr><th>time</th><td>" << info.gen_utime << " (" << time_to_human(info.gen_utime) << ")</td></tr>\n"
           << "<tr><th>lt</th><td>" << info.start_lt << " .. " << info.end_lt << "</td></tr>\n"
           << "<tr><th>global_id</th><td>" << blk.global_id << "</td></tr>\n"
           << "<tr><th>version</th><td>" << info.version << "</td></tr>\n"
@@ -543,7 +587,8 @@ HttpAnswer& HttpAnswer::operator<<(BlockShardsCell shards_c) {
       ton::ShardIdFull shard{id.workchain, id.shard};
       if (ref.not_null()) {
         *this << "<td>" << shard.to_str() << "</td><td><a href=\"" << HttpAnswer::BlockLink{ref->top_block_id()}
-              << "\">" << ref->top_block_id().id.seqno << "</a></td><td>" << ref->created_at() << "</td>"
+              << "\">" << ref->top_block_id().id.seqno << "</a></td><td><span title=\""
+              << time_to_human(ref->created_at()) << "\">" << ref->created_at() << "</span></td>"
               << "<td>" << ref->want_split_ << "</td>"
               << "<td>" << ref->want_merge_ << "</td>"
               << "<td>" << ref->before_split_ << "</td>"

blockchain-explorer/blockchain-explorer-query.cpp

@@ -50,32 +50,6 @@
 #include "vm/vm.h"
 #include "vm/cp0.h"
 
-namespace {
-
-td::Ref<vm::Tuple> prepare_vm_c7(ton::UnixTime now, ton::LogicalTime lt, td::Ref<vm::CellSlice> my_addr,
-                                 const block::CurrencyCollection &balance) {
-  td::BitArray<256> rand_seed;
-  td::RefInt256 rand_seed_int{true};
-  td::Random::secure_bytes(rand_seed.as_slice());
-  if (!rand_seed_int.unique_write().import_bits(rand_seed.cbits(), 256, false)) {
-    return {};
-  }
-  auto tuple = vm::make_tuple_ref(td::make_refint(0x076ef1ea),  // [ magic:0x076ef1ea
-                                  td::make_refint(0),           //   actions:Integer
-                                  td::make_refint(0),           //   msgs_sent:Integer
-                                  td::make_refint(now),         //   unixtime:Integer
-                                  td::make_refint(lt),          //   block_lt:Integer
-                                  td::make_refint(lt),          //   trans_lt:Integer
-                                  std::move(rand_seed_int),     //   rand_seed:Integer
-                                  balance.as_vm_tuple(),        //   balance_remaining:[Integer (Maybe Cell)]
-                                  my_addr,                      //  myself:MsgAddressInt
-                                  vm::StackEntry());            //  global_config:(Maybe Cell) ] = SmartContractInfo;
-  LOG(DEBUG) << "SmartContractInfo initialized with " << vm::StackEntry(tuple).to_string();
-  return vm::make_tuple_ref(std::move(tuple));
-}
-
-}  // namespace
-
 td::Result<ton::BlockIdExt> parse_block_id(std::map<std::string, std::string> &opts, bool allow_empty) {
   if (allow_empty) {
     if (opts.count("workchain") == 0 && opts.count("shard") == 0 && opts.count("seqno") == 0) {
@@ -1343,111 +1317,71 @@ void HttpQueryRunMethod::start_up_query() {
     if (R.is_error()) {
       td::actor::send_closure(SelfId, &HttpQueryRunMethod::abort_query, R.move_as_error_prefix("litequery failed: "));
     } else {
-      td::actor::send_closure(SelfId, &HttpQueryRunMethod::got_account, R.move_as_ok());
+      td::actor::send_closure(SelfId, &HttpQueryRunMethod::got_result, R.move_as_ok());
     }
   });
+
   auto a = ton::create_tl_object<ton::lite_api::liteServer_accountId>(addr_.workchain, addr_.addr);
-  auto query = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getAccountState>(
-                                            ton::create_tl_lite_block_id(block_id_), std::move(a)),
-                                        true);
+  td::int64 method_id = (td::crc16(td::Slice{method_name_}) & 0xffff) | 0x10000;
+
+  // serialize params
+  vm::CellBuilder cb;
+  td::Ref<vm::Cell> cell;
+  if (!(vm::Stack{params_}.serialize(cb) && cb.finalize_to(cell))) {
+    return abort_query(td::Status::Error("cannot serialize stack with get-method parameters"));
+  }
+  auto params_serialized = vm::std_boc_serialize(std::move(cell));
+  if (params_serialized.is_error()) {
+    return abort_query(params_serialized.move_as_error_prefix("cannot serialize stack with get-method parameters : "));
+  }
+
+  auto query = ton::serialize_tl_object(
+      ton::create_tl_object<ton::lite_api::liteServer_runSmcMethod>(
+          0x17, ton::create_tl_lite_block_id(block_id_), std::move(a), method_id, params_serialized.move_as_ok()),
+      true);
   td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
                           std::move(query), std::move(P));
 }
 
-void HttpQueryRunMethod::got_account(td::BufferSlice data) {
-  auto F = ton::fetch_tl_object<ton::lite_api::liteServer_accountState>(std::move(data), true);
+void HttpQueryRunMethod::got_result(td::BufferSlice data) {
+  auto F = ton::fetch_tl_object<ton::lite_api::liteServer_runMethodResult>(std::move(data), true);
   if (F.is_error()) {
-    abort_query(F.move_as_error());
-    return;
+    return abort_query(F.move_as_error());
   }
-
   auto f = F.move_as_ok();
-  data_ = std::move(f->state_);
-  proof_ = std::move(f->proof_);
-  shard_proof_ = std::move(f->shard_proof_);
-  block_id_ = ton::create_block_id(f->id_);
-  res_block_id_ = ton::create_block_id(f->shardblk_);
-
-  finish_query();
-}
-
-void HttpQueryRunMethod::finish_query() {
-  if (promise_) {
-    auto page = [&]() -> std::string {
-      HttpAnswer A{"account", prefix_};
-      A.set_account_id(addr_);
-      A.set_block_id(res_block_id_);
-
-      block::AccountState account_state;
-      account_state.blk = block_id_;
-      account_state.shard_blk = res_block_id_;
-      account_state.shard_proof = std::move(shard_proof_);
-      account_state.proof = std::move(proof_);
-      account_state.state = std::move(data_);
-      auto r_info = account_state.validate(block_id_, addr_);
-      if (r_info.is_error()) {
-        A.abort(r_info.move_as_error());
-        return A.finish();
-      }
-      auto info = r_info.move_as_ok();
-      if (info.root.is_null()) {
-        A.abort(PSTRING() << "account state of " << addr_ << " is empty (cannot run method `" << method_name_ << "`)");
-        return A.finish();
-      }
-      block::gen::Account::Record_account acc;
-      block::gen::AccountStorage::Record store;
-      block::CurrencyCollection balance;
-      if (!(tlb::unpack_cell(info.root, acc) && tlb::csr_unpack(acc.storage, store) &&
-            balance.validate_unpack(store.balance))) {
-        A.abort("error unpacking account state");
-        return A.finish();
-      }
-      int tag = block::gen::t_AccountState.get_tag(*store.state);
-      switch (tag) {
-        case block::gen::AccountState::account_uninit:
-          A.abort(PSTRING() << "account " << addr_ << " not initialized yet (cannot run any methods)");
-          return A.finish();
-        case block::gen::AccountState::account_frozen:
-          A.abort(PSTRING() << "account " << addr_ << " frozen (cannot run any methods)");
-          return A.finish();
-      }
-
-      CHECK(store.state.write().fetch_ulong(1) == 1);  // account_init$1 _:StateInit = AccountState;
-      block::gen::StateInit::Record state_init;
-      CHECK(tlb::csr_unpack(store.state, state_init));
-      auto code = state_init.code->prefetch_ref();
-      auto data = state_init.data->prefetch_ref();
-      auto stack = td::make_ref<vm::Stack>(std::move(params_));
-      td::int64 method_id = (td::crc16(td::Slice{method_name_}) & 0xffff) | 0x10000;
-      stack.write().push_smallint(method_id);
-      long long gas_limit = vm::GasLimits::infty;
-      // OstreamLogger ostream_logger(ctx.error_stream);
-      // auto log = create_vm_log(ctx.error_stream ? &ostream_logger : nullptr);
-      vm::GasLimits gas{gas_limit};
-      LOG(DEBUG) << "creating VM";
-      vm::VmState vm{code, std::move(stack), gas, 1, data, vm::VmLog()};
-      vm.set_c7(prepare_vm_c7(info.gen_utime, info.gen_lt, acc.addr, balance));  // tuple with SmartContractInfo
-      // vm.incr_stack_trace(1);    // enable stack dump after each step
-      int exit_code = ~vm.run();
-      if (exit_code != 0) {
-        A.abort(PSTRING() << "VM terminated with error code " << exit_code);
-        return A.finish();
-      }
-      stack = vm.get_stack_ref();
-      {
-        std::ostringstream os;
-        os << "result: ";
-        stack->dump(os, 3);
-
-        A << HttpAnswer::CodeBlock{os.str()};
-      }
-
+  auto page = [&]() -> std::string {
+    HttpAnswer A{"account", prefix_};
+    A.set_account_id(addr_);
+    A.set_block_id(ton::create_block_id(f->id_));
+    if (f->exit_code_ != 0) {
+      A.abort(PSTRING() << "VM terminated with error code " << f->exit_code_);
       return A.finish();
-    }();
-    auto R = MHD_create_response_from_buffer(page.length(), const_cast<char *>(page.c_str()), MHD_RESPMEM_MUST_COPY);
-    MHD_add_response_header(R, "Content-Type", "text/html");
-    promise_.set_value(std::move(R));
-  }
+    }
+
+    std::ostringstream os;
+    os << "result: ";
+    if (f->result_.empty()) {
+      os << "<none>";
+    } else {
+      auto r_cell = vm::std_boc_deserialize(f->result_);
+      if (r_cell.is_error()) {
+        A.abort(PSTRING() << "cannot deserialize VM result boc: " << r_cell.move_as_error());
+        return A.finish();
+      }
+      auto cs = vm::load_cell_slice(r_cell.move_as_ok());
+      td::Ref<vm::Stack> stack;
+      if (!(vm::Stack::deserialize_to(cs, stack, 0) && cs.empty_ext())) {
+        A.abort("VM result boc cannot be deserialized");
+        return A.finish();
+      }
+      stack->dump(os, 3);
+    }
+    A << HttpAnswer::CodeBlock{os.str()};
+    return A.finish();
+  }();
+  auto R = MHD_create_response_from_buffer(page.length(), const_cast<char *>(page.c_str()), MHD_RESPMEM_MUST_COPY);
+  MHD_add_response_header(R, "Content-Type", "text/html");
+  promise_.set_value(std::move(R));
   stop();
 }
 HttpQueryStatus::HttpQueryStatus(std::string prefix, td::Promise<MHD_Response *> promise)
@@ -1498,7 +1432,7 @@ void HttpQueryStatus::finish_query() {
       for (td::uint32 i = 0; i < results_.ips.size(); i++) {
         A << "<tr>";
         if (results_.ips[i].is_valid()) {
-          A << "<td>" << results_.ips[i] << "</td>";
+          A << "<td>" << results_.ips[i].get_ip_str() << ":" << results_.ips[i].get_port() << "</td>";
         } else {
           A << "<td>hidden</td>";
         }

blockchain-explorer/blockchain-explorer-query.hpp

@@ -311,22 +311,14 @@ class HttpQueryRunMethod : public HttpQueryCommon {
                      std::vector<vm::StackEntry> params, std::string prefix, td::Promise<MHD_Response *> promise);
   HttpQueryRunMethod(std::map<std::string, std::string> opts, std::string prefix, td::Promise<MHD_Response *> promise);
 
-  void finish_query();
-
   void start_up_query() override;
-  void got_account(td::BufferSlice result);
+  void got_result(td::BufferSlice result);
 
  private:
   ton::BlockIdExt block_id_;
   block::StdAddress addr_;
-
   std::string method_name_;
   std::vector<vm::StackEntry> params_;
-
-  td::BufferSlice data_;
-  td::BufferSlice proof_;
-  td::BufferSlice shard_proof_;
-  ton::BlockIdExt res_block_id_;
 };
 
 class HttpQueryStatus : public HttpQueryCommon {

blockchain-explorer/blockchain-explorer.cpp

@@ -52,11 +52,12 @@
 #include "vm/boc.h"
 #include "vm/cellops.h"
 #include "vm/cells/MerkleProof.h"
-#include "vm/cp0.h"
+#include "vm/vm.h"
 
 #include "auto/tl/lite_api.h"
 #include "ton/lite-tl.hpp"
 #include "tl-utils/lite-utils.hpp"
+#include "lite-client/ext-client.h"
 
 #include <microhttpd.h>
 
@@ -103,30 +104,31 @@ class HttpQueryRunner {
         Self->finish(nullptr);
       }
     });
-    mutex_.lock();
     scheduler_ptr->run_in_context_external([&]() { func(std::move(P)); });
   }
   void finish(MHD_Response* response) {
+    std::unique_lock<std::mutex> lock(mutex_);
     response_ = response;
-    mutex_.unlock();
+    cond.notify_all();
   }
   MHD_Response* wait() {
-    mutex_.lock();
-    mutex_.unlock();
+    std::unique_lock<std::mutex> lock(mutex_);
+    cond.wait(lock, [&]() { return response_ != nullptr; });
     return response_;
   }
 
  private:
   std::function<void(td::Promise<MHD_Response*>)> func_;
-  MHD_Response* response_;
+  MHD_Response* response_ = nullptr;
   std::mutex mutex_;
+  std::condition_variable cond;
 };
 
 class CoreActor : public CoreActorInterface {
  private:
   std::string global_config_ = "ton-global.config";
 
-  std::vector<td::actor::ActorOwn<ton::adnl::AdnlExtClient>> clients_;
+  td::actor::ActorOwn<liteclient::ExtClient> client_;
 
   td::uint32 http_port_ = 80;
   MHD_Daemon* daemon_ = nullptr;
@@ -136,35 +138,29 @@ class CoreActor : public CoreActorInterface {
 
   bool hide_ips_ = false;
 
-  std::unique_ptr<ton::adnl::AdnlExtClient::Callback> make_callback(td::uint32 idx) {
-    class Callback : public ton::adnl::AdnlExtClient::Callback {
+  td::unique_ptr<liteclient::ExtClient::Callback> make_callback() {
+    class Callback : public liteclient::ExtClient::Callback {
      public:
-      void on_ready() override {
-        td::actor::send_closure(id_, &CoreActor::conn_ready, idx_);
-      }
-      void on_stop_ready() override {
-        td::actor::send_closure(id_, &CoreActor::conn_closed, idx_);
-      }
-      Callback(td::actor::ActorId<CoreActor> id, td::uint32 idx) : id_(std::move(id)), idx_(idx) {
+      Callback(td::actor::ActorId<CoreActor> id) : id_(std::move(id)) {
       }
 
      private:
       td::actor::ActorId<CoreActor> id_;
-      td::uint32 idx_;
     };
 
-    return std::make_unique<Callback>(actor_id(this), idx);
+    return td::make_unique<Callback>(actor_id(this));
   }
 
   std::shared_ptr<RemoteNodeStatus> new_result_;
   td::int32 attempt_ = 0;
   td::int32 waiting_ = 0;
 
-  std::vector<bool> ready_;
+  size_t n_servers_ = 0;
 
   void run_queries();
-  void got_result(td::uint32 idx, td::int32 attempt, td::Result<td::BufferSlice> data);
-  void send_query(td::uint32 idx);
+  void got_servers_ready(td::int32 attempt, std::vector<bool> ready);
+  void send_ping(td::uint32 idx);
+  void got_ping_result(td::uint32 idx, td::int32 attempt, td::Result<td::BufferSlice> data);
 
   void add_result() {
     if (new_result_) {
@@ -195,12 +191,6 @@ class CoreActor : public CoreActorInterface {
   static CoreActor* instance_;
   td::actor::ActorId<CoreActor> self_id_;
 
-  void conn_ready(td::uint32 idx) {
-    ready_.at(idx) = true;
-  }
-  void conn_closed(td::uint32 idx) {
-    ready_.at(idx) = false;
-  }
   void set_global_config(std::string str) {
     global_config_ = str;
   }
@@ -225,10 +215,7 @@ class CoreActor : public CoreActorInterface {
     hide_ips_ = value;
   }
 
-  void send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promise<td::BufferSlice> promise);
-  void send_lite_query(td::BufferSlice data, td::Promise<td::BufferSlice> promise) override {
-    return send_lite_query(0, std::move(data), std::move(promise));
-  }
+  void send_lite_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise) override;
   void get_last_result(td::Promise<std::shared_ptr<RemoteNodeStatus>> promise) override {
   }
   void get_results(td::uint32 max, td::Promise<RemoteNodeStatusList> promise) override {
@@ -260,7 +247,7 @@ class CoreActor : public CoreActorInterface {
   CoreActor() {
   }
 
-  static int get_arg_iterate(void* cls, enum MHD_ValueKind kind, const char* key, const char* value) {
+  static MHD_RESULT get_arg_iterate(void* cls, enum MHD_ValueKind kind, const char* key, const char* value) {
     auto X = static_cast<std::map<std::string, std::string>*>(cls);
     if (key && value && std::strlen(key) > 0 && std::strlen(value) > 0) {
       X->emplace(key, urldecode(td::Slice{value}, false));
@@ -277,7 +264,7 @@ class CoreActor : public CoreActorInterface {
     ~HttpRequestExtra() {
       MHD_destroy_post_processor(postprocessor);
     }
-    static int iterate_post(void* coninfo_cls, enum MHD_ValueKind kind, const char* key, const char* filename,
+    static MHD_RESULT iterate_post(void* coninfo_cls, enum MHD_ValueKind kind, const char* key, const char* filename,
                             const char* content_type, const char* transfer_encoding, const char* data, uint64_t off,
                             size_t size) {
       auto ptr = static_cast<HttpRequestExtra*>(coninfo_cls);
@@ -305,10 +292,10 @@ class CoreActor : public CoreActorInterface {
     }
   }
 
-  static int process_http_request(void* cls, struct MHD_Connection* connection, const char* url, const char* method,
+  static MHD_RESULT process_http_request(void* cls, struct MHD_Connection* connection, const char* url, const char* method,
                                   const char* version, const char* upload_data, size_t* upload_data_size, void** ptr) {
     struct MHD_Response* response = nullptr;
-    int ret;
+    MHD_RESULT ret;
 
     bool is_post = false;
     if (std::strcmp(method, "GET") == 0) {
@@ -448,33 +435,27 @@ class CoreActor : public CoreActorInterface {
   }
 
   void run() {
+    std::vector<liteclient::LiteServerConfig> servers;
     if (remote_public_key_.empty()) {
       auto G = td::read_file(global_config_).move_as_ok();
       auto gc_j = td::json_decode(G.as_slice()).move_as_ok();
       ton::ton_api::liteclient_config_global gc;
       ton::ton_api::from_json(gc, gc_j.get_object()).ensure();
-
-      CHECK(gc.liteservers_.size() > 0);
-      td::uint32 size = static_cast<td::uint32>(gc.liteservers_.size());
-      ready_.resize(size, false);
-
-      for (td::uint32 i = 0; i < size; i++) {
-        auto& cli = gc.liteservers_[i];
-        td::IPAddress addr;
-        addr.init_host_port(td::IPAddress::ipv4_to_str(cli->ip_), cli->port_).ensure();
-        addrs_.push_back(addr);
-        clients_.emplace_back(ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull::create(cli->id_).move_as_ok(),
-                                                               addr, make_callback(i)));
+      auto r_servers = liteclient::LiteServerConfig::parse_global_config(gc);
+      r_servers.ensure();
+      servers = r_servers.move_as_ok();
+      for (const auto& serv : servers) {
+        addrs_.push_back(serv.addr);
       }
     } else {
       if (!remote_addr_.is_valid()) {
         LOG(FATAL) << "remote addr not set";
       }
-      ready_.resize(1, false);
       addrs_.push_back(remote_addr_);
-      clients_.emplace_back(ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull{remote_public_key_},
-                                                             remote_addr_, make_callback(0)));
+      servers.push_back(liteclient::LiteServerConfig{ton::adnl::AdnlNodeIdFull{remote_public_key_}, remote_addr_});
     }
+    n_servers_ = servers.size();
+    client_ = liteclient::ExtClient::create(std::move(servers), make_callback(), true);
     daemon_ = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY, static_cast<td::uint16>(http_port_), nullptr, nullptr,
                                &process_http_request, nullptr, MHD_OPTION_NOTIFY_COMPLETED, request_completed, nullptr,
                                MHD_OPTION_THREAD_POOL_SIZE, 16, MHD_OPTION_END);
@@ -482,7 +463,46 @@ class CoreActor : public CoreActorInterface {
   }
 };
 
-void CoreActor::got_result(td::uint32 idx, td::int32 attempt, td::Result<td::BufferSlice> R) {
+void CoreActor::run_queries() {
+  waiting_ = 0;
+  new_result_ = std::make_shared<RemoteNodeStatus>(n_servers_, td::Timestamp::at_unix(attempt_ * 60));
+  td::actor::send_closure(client_, &liteclient::ExtClient::get_servers_status,
+                          [SelfId = actor_id(this), attempt = attempt_](td::Result<std::vector<bool>> R) {
+                            R.ensure();
+                            td::actor::send_closure(SelfId, &CoreActor::got_servers_ready, attempt, R.move_as_ok());
+                          });
+}
+
+void CoreActor::got_servers_ready(td::int32 attempt, std::vector<bool> ready) {
+  if (attempt != attempt_) {
+    return;
+  }
+  CHECK(ready.size() == n_servers_);
+  for (td::uint32 i = 0; i < n_servers_; i++) {
+    if (ready[i]) {
+      send_ping(i);
+    }
+  }
+  CHECK(waiting_ >= 0);
+  if (waiting_ == 0) {
+    add_result();
+  }
+}
+
+void CoreActor::send_ping(td::uint32 idx) {
+  waiting_++;
+  auto query = ton::create_tl_object<ton::lite_api::liteServer_getMasterchainInfo>();
+  auto q = ton::create_tl_object<ton::lite_api::liteServer_query>(serialize_tl_object(query, true));
+
+  auto P =
+      td::PromiseCreator::lambda([SelfId = actor_id(this), idx, attempt = attempt_](td::Result<td::BufferSlice> R) {
+        td::actor::send_closure(SelfId, &CoreActor::got_ping_result, idx, attempt, std::move(R));
+      });
+  td::actor::send_closure(client_, &liteclient::ExtClient::send_query_to_server, "query", serialize_tl_object(q, true),
+                          idx, td::Timestamp::in(10.0), std::move(P));
+}
+
+void CoreActor::got_ping_result(td::uint32 idx, td::int32 attempt, td::Result<td::BufferSlice> R) {
   if (attempt != attempt_) {
     return;
   }
@@ -523,39 +543,7 @@ void CoreActor::got_result(td::uint32 idx, td::int32 attempt, td::Result<td::Buf
   }
 }
 
-void CoreActor::send_query(td::uint32 idx) {
-  if (!ready_[idx]) {
-    return;
-  }
-  waiting_++;
-  auto query = ton::create_tl_object<ton::lite_api::liteServer_getMasterchainInfo>();
-  auto q = ton::create_tl_object<ton::lite_api::liteServer_query>(serialize_tl_object(query, true));
-
-  auto P =
-      td::PromiseCreator::lambda([SelfId = actor_id(this), idx, attempt = attempt_](td::Result<td::BufferSlice> R) {
-        td::actor::send_closure(SelfId, &CoreActor::got_result, idx, attempt, std::move(R));
-      });
-  td::actor::send_closure(clients_[idx], &ton::adnl::AdnlExtClient::send_query, "query", serialize_tl_object(q, true),
-                          td::Timestamp::in(10.0), std::move(P));
-}
-
-void CoreActor::run_queries() {
-  waiting_ = 0;
-  new_result_ = std::make_shared<RemoteNodeStatus>(ready_.size(), td::Timestamp::at_unix(attempt_ * 60));
-  for (td::uint32 i = 0; i < ready_.size(); i++) {
-    send_query(i);
-  }
-  CHECK(waiting_ >= 0);
-  if (waiting_ == 0) {
-    add_result();
-  }
-}
-
-void CoreActor::send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promise<td::BufferSlice> promise) {
-  if (!ready_[idx]) {
-    promise.set_error(td::Status::Error(ton::ErrorCode::notready, "ext conn not ready"));
-    return;
-  }
+void CoreActor::send_lite_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise) {
   auto P = td::PromiseCreator::lambda([promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
     if (R.is_error()) {
       promise.set_error(R.move_as_error());
@@ -573,7 +561,7 @@ void CoreActor::send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promi
     promise.set_value(std::move(B));
   });
   auto q = ton::create_tl_object<ton::lite_api::liteServer_query>(std::move(query));
-  td::actor::send_closure(clients_[idx], &ton::adnl::AdnlExtClient::send_query, "query", serialize_tl_object(q, true),
+  td::actor::send_closure(client_, &liteclient::ExtClient::send_query, "query", serialize_tl_object(q, true),
                           td::Timestamp::in(10.0), std::move(P));
 }
 
@@ -654,7 +642,7 @@ int main(int argc, char* argv[]) {
   });
 #endif
 
-  vm::init_op_cp0();
+  vm::init_vm().ensure();
 
   td::actor::Scheduler scheduler({2});
   scheduler_ptr = &scheduler;

blockchain-explorer/blockchain-explorer.hpp

@@ -31,9 +31,21 @@
 #include "td/utils/buffer.h"
 #include "ton/ton-types.h"
 #include "td/utils/port/IPAddress.h"
+#include <microhttpd.h>
 
 #define MAX_POST_SIZE (64 << 10)
 
+// Beginning with v0.9.71, libmicrohttpd changed the return type of most
+// functions from int to enum MHD_Result
+// https://git.gnunet.org/gnunet.git/tree/src/include/gnunet_mhd_compat.h
+// proposes to define a constant for the return type so it works well
+// with all versions of libmicrohttpd
+#if MHD_VERSION >= 0x00097002
+#define MHD_RESULT enum MHD_Result
+#else
+#define MHD_RESULT int
+#endif
+
 extern bool local_scripts_;
 
 class CoreActorInterface : public td::actor::Actor {

catchain/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
 
 if (NOT OPENSSL_FOUND)
   find_package(OpenSSL REQUIRED)
@@ -34,6 +34,5 @@ target_include_directories(overlay PUBLIC
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/.. 
   ${OPENSSL_INCLUDE_DIR}
 )
-target_link_libraries(catchain PRIVATE tdutils tdactor adnl tl_api dht tdfec
-  overlay)
+target_link_libraries(catchain PRIVATE tdutils tdactor adnl tl_api dht tdfec overlay)
 

catchain/catchain-block.cpp

@@ -22,8 +22,8 @@ namespace ton {
 
 namespace catchain {
 
-std::unique_ptr<CatChainBlock> CatChainBlock::create(td::uint32 src, td::uint32 fork, PublicKeyHash src_hash,
-                                                     CatChainBlockHeight height, CatChainBlockHash hash,
+std::unique_ptr<CatChainBlock> CatChainBlock::create(td::uint32 src, td::uint32 fork, const PublicKeyHash &src_hash,
+                                                     CatChainBlockHeight height, const CatChainBlockHash &hash,
                                                      td::SharedSlice payload, CatChainBlock *prev,
                                                      std::vector<CatChainBlock *> deps,
                                                      std::vector<CatChainBlockHeight> vt) {
@@ -31,10 +31,10 @@ std::unique_ptr<CatChainBlock> CatChainBlock::create(td::uint32 src, td::uint32
                                              std::move(deps), std::move(vt));
 }
 
-CatChainBlockImpl::CatChainBlockImpl(td::uint32 src, td::uint32 fork, PublicKeyHash src_hash,
-                                     CatChainBlockHeight height, CatChainBlockHash hash, td::SharedSlice payload,
-                                     CatChainBlock *prev, std::vector<CatChainBlock *> deps,
-                                     std::vector<CatChainBlockHeight> vt)
+CatChainBlockImpl::CatChainBlockImpl(td::uint32 src, td::uint32 fork, const PublicKeyHash &src_hash,
+                                     CatChainBlockHeight height, const CatChainBlockHash &hash,
+                                     td::SharedSlice payload, CatChainBlock *prev,
+                                     std::vector<CatChainBlock *> deps, std::vector<CatChainBlockHeight> vt)
     : src_(src)
     , fork_(fork)
     , src_hash_(src_hash)
@@ -47,7 +47,7 @@ CatChainBlockImpl::CatChainBlockImpl(td::uint32 src, td::uint32 fork, PublicKeyH
 }
 
 bool CatChainBlockImpl::is_descendant_of(CatChainBlock *block) {
-  auto fork = block->fork();
+  td::uint32 fork = block->fork();
   if (fork >= vt_.size()) {
     return false;
   }

catchain/catchain-block.hpp

@@ -103,8 +103,8 @@ class CatChainBlockImpl : public CatChainBlock {
 
   bool is_descendant_of(CatChainBlock *block) override;
 
-  CatChainBlockImpl(td::uint32 src, td::uint32 fork, PublicKeyHash src_hash, CatChainBlockHeight height,
-                    CatChainBlockHash hash, td::SharedSlice payload, CatChainBlock *prev,
+  CatChainBlockImpl(td::uint32 src, td::uint32 fork, const PublicKeyHash &src_hash, CatChainBlockHeight height,
+                    const CatChainBlockHash &hash, td::SharedSlice payload, CatChainBlock *prev,
                     std::vector<CatChainBlock *> deps, std::vector<CatChainBlockHeight> vt);
 };
 

catchain/catchain-received-block.cpp

@@ -33,7 +33,7 @@ void CatChainReceivedBlockImpl::initialize(tl_object_ptr<ton_api::catchain_block
   }
 
   payload_ = std::move(payload);
-  CHECK(payload_.size() > 0);
+  CHECK(!payload_.empty());
 
   prev_ = dynamic_cast<CatChainReceivedBlockImpl *>(chain_->create_block(std::move(block->data_->prev_)));
   CHECK(prev_ != nullptr);
@@ -51,7 +51,7 @@ void CatChainReceivedBlockImpl::initialize(tl_object_ptr<ton_api::catchain_block
     set_ill();
     return;
   }
-  for (auto &X : block_deps_) {
+  for (CatChainReceivedBlockImpl *X : block_deps_) {
     if (X->is_ill()) {
       set_ill();
       return;
@@ -63,17 +63,17 @@ void CatChainReceivedBlockImpl::initialize(tl_object_ptr<ton_api::catchain_block
     if (!prev_->delivered()) {
       pending_deps++;
     } else {
-      update_deps(prev_);
+      update_vt(prev_);
     }
     if (!prev_->delivered()) {
       prev_->add_rev_dep(this);
     }
   }
-  for (auto &X : block_deps_) {
+  for (CatChainReceivedBlockImpl *X : block_deps_) {
     if (!X->delivered()) {
       pending_deps++;
     } else {
-      update_deps(X);
+      update_vt(X);
     }
     if (!X->delivered()) {
       X->add_rev_dep(this);
@@ -121,11 +121,11 @@ void CatChainReceivedBlockImpl::initialize_fork() {
     }
   }
 
-  if (deps_.size() < fork_id_ + 1) {
-    deps_.resize(fork_id_ + 1, 0);
+  if (vt_.size() < fork_id_ + 1) {
+    vt_.resize(fork_id_ + 1, 0);
   }
-  CHECK(deps_[fork_id_] < height_);
-  deps_[fork_id_] = height_;
+  CHECK(vt_[fork_id_] < height_);
+  vt_[fork_id_] = height_;
 }
 
 void CatChainReceivedBlockImpl::pre_deliver(ton_api::catchain_block_data_fork &b) {
@@ -153,7 +153,7 @@ void CatChainReceivedBlockImpl::pre_deliver(ton_api::catchain_block_data_fork &b
     return;
   }
 
-  auto S = chain_->get_source(b.left_->src_);
+  CatChainReceiverSource *S = chain_->get_source(b.left_->src_);
   S->on_found_fork_proof(
       create_serialize_tl_object<ton_api::catchain_block_data_fork>(std::move(b.left_), std::move(b.right_)));
   S->blame(fork_id_, height_);
@@ -173,15 +173,15 @@ void CatChainReceivedBlockImpl::pre_deliver() {
   CHECK(pending_deps_ == 0);
   CHECK(in_db_);
 
-  auto M = chain_->get_source(source_id_);
+  CatChainReceiverSource *M = chain_->get_source(source_id_);
 
-  auto d = prev_ ? &prev_->deps_ : nullptr;
+  std::vector<CatChainBlockHeight> *d = prev_ ? &prev_->vt_ : nullptr;
 
-  for (auto &X : block_deps_) {
-    auto S = chain_->get_source(X->get_source_id());
-    auto &f = S->get_forks();
+  for (CatChainReceivedBlockImpl *X : block_deps_) {
+    CatChainReceiverSource *S = chain_->get_source(X->get_source_id());
+    const std::vector<td::uint32> &f = S->get_forks();
     if (d) {
-      auto &dd = *d;
+      const std::vector<CatChainBlockHeight> &dd = *d;
       if (X->get_fork_id() < dd.size() && X->get_height() <= dd[X->get_fork_id()]) {
         VLOG(CATCHAIN_WARNING) << this << ": has direct dep from source " << X->get_source_id() << " and prev block "
                                << " has newer indirect dep";
@@ -190,8 +190,8 @@ void CatChainReceivedBlockImpl::pre_deliver() {
       }
     }
     if (S->blamed() && d) {
-      auto &dd = *d;
-      for (auto x : f) {
+      const std::vector<CatChainBlockHeight> &dd = *d;
+      for (td::uint32 x : f) {
         if (x != X->get_fork_id() && dd.size() > x && dd[x] > 0) {
           VLOG(CATCHAIN_WARNING) << this << ": has direct dep from source " << X->get_source_id() << " and prev block "
                                  << " has indirect dep to another fork of this source " << x << " " << X->get_fork_id()
@@ -201,7 +201,7 @@ void CatChainReceivedBlockImpl::pre_deliver() {
           return;
         }
       }
-      auto v = S->get_blamed_heights();
+      std::vector<CatChainBlockHeight> v = S->get_blamed_heights();
 
       for (size_t i = 0; i < v.size() && i < dd.size(); i++) {
         if (v[i] > 0 && dd[i] >= v[i]) {
@@ -220,7 +220,7 @@ void CatChainReceivedBlockImpl::pre_deliver() {
   if (X.is_error()) {
     is_custom_ = true;
   } else {
-    ton_api::downcast_call(*X.move_as_ok().get(), [Self = this](auto &obj) { Self->pre_deliver(obj); });
+    ton_api::downcast_call(*X.move_as_ok(), [Self = this](auto &obj) { Self->pre_deliver(obj); });
   }
 }
 
@@ -237,7 +237,7 @@ void CatChainReceivedBlockImpl::deliver() {
   state_ = bs_delivered;
   VLOG(CATCHAIN_DEBUG) << this << ": delivered";
 
-  for (auto &B : rev_deps_) {
+  for (CatChainReceivedBlockImpl *B : rev_deps_) {
     B->dep_delivered(this);
   }
   rev_deps_.clear();
@@ -250,10 +250,10 @@ void CatChainReceivedBlockImpl::set_ill() {
     return;
   }
   VLOG(CATCHAIN_WARNING) << this << ": got ill";
-  auto M = chain_->get_source(source_id_);
+  CatChainReceiverSource *M = chain_->get_source(source_id_);
   M->blame();
   state_ = bs_ill;
-  for (auto &B : rev_deps_) {
+  for (CatChainReceivedBlockImpl *B : rev_deps_) {
     B->dep_ill(this);
   }
 }
@@ -262,14 +262,14 @@ void CatChainReceivedBlockImpl::dep_ill(CatChainReceivedBlockImpl *block) {
   set_ill();
 }
 
-void CatChainReceivedBlockImpl::update_deps(CatChainReceivedBlockImpl *block) {
-  auto &d = block->deps_;
-  if (d.size() > deps_.size()) {
-    deps_.resize(d.size(), 0);
+void CatChainReceivedBlockImpl::update_vt(CatChainReceivedBlockImpl *block) {
+  const std::vector<CatChainBlockHeight> &d = block->vt_;
+  if (d.size() > vt_.size()) {
+    vt_.resize(d.size(), 0);
   }
   for (size_t i = 0; i < d.size(); i++) {
-    if (deps_[i] < d[i]) {
-      deps_[i] = d[i];
+    if (vt_[i] < d[i]) {
+      vt_[i] = d[i];
     }
   }
 }
@@ -279,7 +279,7 @@ void CatChainReceivedBlockImpl::dep_delivered(CatChainReceivedBlockImpl *block)
     return;
   }
   CHECK(!block->is_ill());
-  update_deps(block);
+  update_vt(block);
   pending_deps_--;
   if (pending_deps_ == 0 && in_db_) {
     schedule();
@@ -332,35 +332,37 @@ void CatChainReceivedBlockImpl::find_pending_deps(std::vector<CatChainBlockHash>
   if (prev_) {
     prev_->find_pending_deps(vec, max_size);
   }
-  for (auto &X : block_deps_) {
+  for (CatChainReceivedBlockImpl *X : block_deps_) {
     X->find_pending_deps(vec, max_size);
   }
 }
 
-tl_object_ptr<ton_api::catchain_block_id> CatChainReceivedBlock::block_id(CatChainReceiver *chain,
-                                                                          tl_object_ptr<ton_api::catchain_block> &block,
-                                                                          td::Slice payload) {
+tl_object_ptr<ton_api::catchain_block_id> CatChainReceivedBlock::block_id(
+    const CatChainReceiver *chain, const tl_object_ptr<ton_api::catchain_block> &block, const td::Slice &payload) {
+  td::Bits256 hash = data_payload_hash(chain, block->data_, payload);
   return create_tl_object<ton_api::catchain_block_id>(block->incarnation_, chain->get_source_hash(block->src_).tl(),
-                                                      block->height_, sha256_bits256(payload));
+                                                      block->height_, hash);
 }
 tl_object_ptr<ton_api::catchain_block_id> CatChainReceivedBlock::block_id(
-    CatChainReceiver *chain, tl_object_ptr<ton_api::catchain_block_dep> &block) {
+    const CatChainReceiver *chain, const tl_object_ptr<ton_api::catchain_block_dep> &block) {
   return create_tl_object<ton_api::catchain_block_id>(
       chain->get_incarnation(), chain->get_source_hash(block->src_).tl(), block->height_, block->data_hash_);
 }
 
-CatChainBlockHash CatChainReceivedBlock::block_hash(CatChainReceiver *chain,
-                                                    tl_object_ptr<ton_api::catchain_block> &block, td::Slice payload) {
+CatChainBlockHash CatChainReceivedBlock::block_hash(const CatChainReceiver *chain,
+                                                    const tl_object_ptr<ton_api::catchain_block> &block,
+                                                    const td::Slice &payload) {
   return get_tl_object_sha_bits256(block_id(chain, block, payload));
 }
 
-CatChainBlockHash CatChainReceivedBlock::block_hash(CatChainReceiver *chain,
-                                                    tl_object_ptr<ton_api::catchain_block_dep> &block) {
+CatChainBlockHash CatChainReceivedBlock::block_hash(const CatChainReceiver *chain,
+                                                    const tl_object_ptr<ton_api::catchain_block_dep> &block) {
   return get_tl_object_sha_bits256(block_id(chain, block));
 }
 
-td::Status CatChainReceivedBlock::pre_validate_block(CatChainReceiver *chain,
-                                                     tl_object_ptr<ton_api::catchain_block> &block, td::Slice payload) {
+td::Status CatChainReceivedBlock::pre_validate_block(const CatChainReceiver *chain,
+                                                     const tl_object_ptr<ton_api::catchain_block> &block,
+                                                     const td::Slice &payload) {
   CHECK(block->incarnation_ == chain->get_incarnation());
   if (block->height_ <= 0) {
     return td::Status::Error(ErrorCode::protoviolation, std::string("bad height ") + std::to_string(block->height_));
@@ -397,7 +399,7 @@ td::Status CatChainReceivedBlock::pre_validate_block(CatChainReceiver *chain,
 
   std::set<td::uint32> used;
   used.insert(block->src_);
-  for (auto &X : block->data_->deps_) {
+  for (const auto &X : block->data_->deps_) {
     if (used.find(X->src_) != used.end()) {
       return td::Status::Error(ErrorCode::protoviolation, "two deps from same source");
     }
@@ -405,19 +407,19 @@ td::Status CatChainReceivedBlock::pre_validate_block(CatChainReceiver *chain,
   }
 
   TRY_STATUS(chain->validate_block_sync(block->data_->prev_));
-  for (auto &X : block->data_->deps_) {
+  for (const auto &X : block->data_->deps_) {
     TRY_STATUS(chain->validate_block_sync(X));
   }
 
-  if (payload.size() == 0) {
+  if (payload.empty()) {
     return td::Status::Error(ErrorCode::protoviolation, "empty payload");
   }
 
   return td::Status::OK();
 }
 
-td::Status CatChainReceivedBlock::pre_validate_block(CatChainReceiver *chain,
-                                                     tl_object_ptr<ton_api::catchain_block_dep> &block) {
+td::Status CatChainReceivedBlock::pre_validate_block(const CatChainReceiver *chain,
+                                                     const tl_object_ptr<ton_api::catchain_block_dep> &block) {
   if (block->height_ < 0) {
     return td::Status::Error(ErrorCode::protoviolation, std::string("bad height ") + std::to_string(block->height_));
   }
@@ -430,7 +432,7 @@ td::Status CatChainReceivedBlock::pre_validate_block(CatChainReceiver *chain,
       return td::Status::Error(ErrorCode::protoviolation,
                                std::string("bad src (first block) ") + std::to_string(block->src_));
     }
-    if (block->data_hash_ != chain->get_incarnation() || block->signature_.size() != 0) {
+    if (block->data_hash_ != chain->get_incarnation() || !block->signature_.empty()) {
       return td::Status::Error(ErrorCode::protoviolation, std::string("bad first block"));
     }
   }
@@ -443,9 +445,10 @@ tl_object_ptr<ton_api::catchain_block> CatChainReceivedBlockImpl::export_tl() co
   CHECK(height_ > 0);
   std::vector<tl_object_ptr<ton_api::catchain_block_dep>> deps;
 
-  for (auto &B : block_deps_) {
+  for (CatChainReceivedBlockImpl *B : block_deps_) {
     deps.push_back(B->export_tl_dep());
   }
+  CHECK(deps.size() <= chain_->opts().max_deps)
 
   return create_tl_object<ton_api::catchain_block>(
       chain_->get_incarnation(), source_id_, height_,
@@ -454,35 +457,34 @@ tl_object_ptr<ton_api::catchain_block> CatChainReceivedBlockImpl::export_tl() co
 }
 
 tl_object_ptr<ton_api::catchain_block_dep> CatChainReceivedBlockImpl::export_tl_dep() const {
-  return create_tl_object<ton_api::catchain_block_dep>(source_id_, height_, data_hash_,
+  return create_tl_object<ton_api::catchain_block_dep>(source_id_, height_, data_payload_hash_,
                                                        signature_.clone_as_buffer_slice());
 }
 
-CatChainReceivedBlockImpl::CatChainReceivedBlockImpl(td::uint32 source_id, CatChainSessionId hash,
+CatChainReceivedBlockImpl::CatChainReceivedBlockImpl(td::uint32 source_id, const CatChainBlockPayloadHash &hash,
                                                      CatChainReceiver *chain) {
   chain_ = chain;
   state_ = bs_delivered;
   fork_id_ = 0;
   source_id_ = source_id;
-  data_ = nullptr;
-  prev_ = nullptr;
   height_ = 0;
 
-  data_hash_ = hash;
-  hash_ = get_tl_object_sha_bits256(create_tl_object<ton_api::catchain_block_id>(
-      chain->get_incarnation(), chain->get_incarnation(), height_, data_hash_));
+  data_payload_hash_ = hash;
+  block_id_hash_ = get_tl_object_sha_bits256(create_tl_object<ton_api::catchain_block_id>(
+      chain->get_incarnation(), chain->get_incarnation(), height_, data_payload_hash_));
 }
 
 CatChainReceivedBlockImpl::CatChainReceivedBlockImpl(tl_object_ptr<ton_api::catchain_block> block,
                                                      td::SharedSlice payload, CatChainReceiver *chain) {
   chain_ = chain;
-  data_hash_ = sha256_bits256(payload.as_slice());
-  hash_ = get_tl_object_sha_bits256(create_tl_object<ton_api::catchain_block_id>(
-      block->incarnation_, chain->get_source_hash(block->src_).tl(), block->height_, data_hash_));
+  data_payload_hash_ = data_payload_hash(chain, block->data_, payload);
+  block_id_hash_ = get_tl_object_sha_bits256(create_tl_object<ton_api::catchain_block_id>(
+      block->incarnation_, chain->get_source_hash(block->src_).tl(), block->height_, data_payload_hash_));
   height_ = block->height_;
   source_id_ = block->src_;
+  CHECK(height_ <= get_max_block_height(chain->opts(), chain->get_sources_cnt()));
 
-  auto S = chain_->get_source(source_id_);
+  CatChainReceiverSource *S = chain_->get_source(source_id_);
   S->on_new_block(this);
 
   initialize(std::move(block), std::move(payload));
@@ -491,14 +493,14 @@ CatChainReceivedBlockImpl::CatChainReceivedBlockImpl(tl_object_ptr<ton_api::catc
 CatChainReceivedBlockImpl::CatChainReceivedBlockImpl(tl_object_ptr<ton_api::catchain_block_dep> block,
                                                      CatChainReceiver *chain) {
   chain_ = chain;
-  data_hash_ = block->data_hash_;
+  data_payload_hash_ = block->data_hash_;
   source_id_ = block->src_;
   signature_ = td::SharedSlice{block->signature_.as_slice()};
-  hash_ = get_tl_object_sha_bits256(create_tl_object<ton_api::catchain_block_id>(
-      chain_->get_incarnation(), chain_->get_source_hash(source_id_).tl(), block->height_, data_hash_));
+  block_id_hash_ = get_tl_object_sha_bits256(create_tl_object<ton_api::catchain_block_id>(
+      chain_->get_incarnation(), chain_->get_source_hash(source_id_).tl(), block->height_, data_payload_hash_));
   height_ = block->height_;
 
-  auto S = chain_->get_source(source_id_);
+  CatChainReceiverSource *S = chain_->get_source(source_id_);
   S->on_new_block(this);
 }
 
@@ -513,9 +515,24 @@ std::unique_ptr<CatChainReceivedBlock> CatChainReceivedBlock::create(tl_object_p
 }
 
 std::unique_ptr<CatChainReceivedBlock> CatChainReceivedBlock::create_root(td::uint32 source_id,
-                                                                          CatChainSessionId data_hash,
+                                                                          CatChainSessionId session_id,
                                                                           CatChainReceiver *chain) {
-  return std::make_unique<CatChainReceivedBlockImpl>(source_id, data_hash, chain);
+  return std::make_unique<CatChainReceivedBlockImpl>(source_id, session_id, chain);
+}
+
+CatChainBlockPayloadHash CatChainReceivedBlock::data_payload_hash(
+    const CatChainReceiver *chain, const tl_object_ptr<ton_api::catchain_block_data> &data, const td::Slice &payload) {
+  td::Bits256 hash = sha256_bits256(payload);
+  if (chain->opts().block_hash_covers_data) {
+    td::Bits256 data_hash = get_tl_object_sha_bits256(data);
+    char buf[32 * 2];
+    CHECK(hash.as_array().size() == 32 && data_hash.as_array().size() == 32);
+    std::copy(hash.as_array().begin(), hash.as_array().end(), buf);
+    std::copy(data_hash.as_array().begin(), data_hash.as_array().end(), buf + 32);
+    return sha256_bits256(td::Slice(buf, buf + 64));
+  } else {
+    return hash;
+  }
 }
 
 }  // namespace catchain

catchain/catchain-received-block.h

@@ -30,7 +30,6 @@ namespace catchain {
 
 class CatChainReceiver;
 class CatChainReceiverSource;
-class CatChainReceiverFork;
 
 class CatChainReceivedBlock {
  public:
@@ -43,7 +42,7 @@ class CatChainReceivedBlock {
   virtual CatChainReceivedBlock *get_prev() const = 0;
   virtual CatChainBlockHash get_prev_hash() const = 0;
 
-  virtual const std::vector<CatChainBlockHeight> &get_deps() const = 0;
+  virtual const std::vector<CatChainBlockHeight> &get_vt() const = 0;
   virtual std::vector<CatChainBlockHash> get_dep_hashes() const = 0;
 
   virtual CatChainReceiver *get_chain() const = 0;
@@ -56,6 +55,8 @@ class CatChainReceivedBlock {
 
   virtual void find_pending_deps(std::vector<CatChainBlockHash> &vec, td::uint32 max_size) const = 0;
 
+  virtual bool has_rev_deps() const = 0;
+
  public:
   // state
   virtual bool initialized() const = 0;
@@ -76,20 +77,28 @@ class CatChainReceivedBlock {
                                                        td::SharedSlice payload, CatChainReceiver *chain);
   static std::unique_ptr<CatChainReceivedBlock> create(tl_object_ptr<ton_api::catchain_block_dep> block,
                                                        CatChainReceiver *chain);
-  static std::unique_ptr<CatChainReceivedBlock> create_root(td::uint32 source_id, CatChainBlockPayloadHash data_hash,
+  static std::unique_ptr<CatChainReceivedBlock> create_root(td::uint32 source_id, CatChainSessionId session_id,
                                                             CatChainReceiver *chain);
 
-  static tl_object_ptr<ton_api::catchain_block_id> block_id(CatChainReceiver *chain,
-                                                            tl_object_ptr<ton_api::catchain_block> &block,
-                                                            td::Slice payload);
-  static tl_object_ptr<ton_api::catchain_block_id> block_id(CatChainReceiver *chain,
-                                                            tl_object_ptr<ton_api::catchain_block_dep> &block);
-  static CatChainBlockHash block_hash(CatChainReceiver *chain, tl_object_ptr<ton_api::catchain_block> &block,
-                                      td::Slice payload);
-  static CatChainBlockHash block_hash(CatChainReceiver *chain, tl_object_ptr<ton_api::catchain_block_dep> &block);
-  static td::Status pre_validate_block(CatChainReceiver *chain, tl_object_ptr<ton_api::catchain_block> &block,
-                                       td::Slice payload);
-  static td::Status pre_validate_block(CatChainReceiver *chain, tl_object_ptr<ton_api::catchain_block_dep> &block);
+  static tl_object_ptr<ton_api::catchain_block_id> block_id(const CatChainReceiver *chain,
+                                                            const tl_object_ptr<ton_api::catchain_block> &block,
+                                                            const td::Slice &payload);
+  static tl_object_ptr<ton_api::catchain_block_id> block_id(const CatChainReceiver *chain,
+                                                            const tl_object_ptr<ton_api::catchain_block_dep> &block);
+  static CatChainBlockHash block_hash(const CatChainReceiver *chain,
+                                      const tl_object_ptr<ton_api::catchain_block> &block,
+                                      const td::Slice &payload);
+  static CatChainBlockHash block_hash(const CatChainReceiver *chain,
+                                      const tl_object_ptr<ton_api::catchain_block_dep> &block);
+  static td::Status pre_validate_block(const CatChainReceiver *chain,
+                                       const tl_object_ptr<ton_api::catchain_block> &block,
+                                       const td::Slice &payload);
+  static td::Status pre_validate_block(const CatChainReceiver *chain,
+                                       const tl_object_ptr<ton_api::catchain_block_dep> &block);
+  static CatChainBlockPayloadHash data_payload_hash(const CatChainReceiver *chain,
+                                                    const tl_object_ptr<ton_api::catchain_block_data> &data,
+                                                    const td::Slice &payload);
+
 
   virtual ~CatChainReceivedBlock() = default;
 };

catchain/catchain-received-block.hpp

@@ -26,15 +26,14 @@ namespace catchain {
 
 class CatChainReceiver;
 class CatChainReceiverSource;
-class CatChainReceiverFork;
 
-class CatChainReceivedBlockImpl : public CatChainReceivedBlock {
+class CatChainReceivedBlockImpl final : public CatChainReceivedBlock {
  public:
   const td::SharedSlice &get_payload() const override {
     return payload_;
   }
   CatChainBlockHash get_hash() const override {
-    return hash_;
+    return block_id_hash_;
   }
   const td::SharedSlice &get_signature() const override {
     return signature_;
@@ -46,8 +45,8 @@ class CatChainReceivedBlockImpl : public CatChainReceivedBlock {
   CatChainReceivedBlock *get_prev() const override;
   CatChainBlockHash get_prev_hash() const override;
 
-  const std::vector<CatChainBlockHeight> &get_deps() const override {
-    return deps_;
+  const std::vector<CatChainBlockHeight> &get_vt() const override {
+    return vt_;
   }
 
   std::vector<CatChainBlockHash> get_dep_hashes() const override;
@@ -69,6 +68,10 @@ class CatChainReceivedBlockImpl : public CatChainReceivedBlock {
 
   void find_pending_deps(std::vector<CatChainBlockHash> &vec, td::uint32 max_size) const override;
 
+  bool has_rev_deps() const override {
+    return !rev_deps_.empty();
+  }
+
  public:
   bool initialized() const override {
     return state_ >= bs_initialized;
@@ -114,7 +117,7 @@ class CatChainReceivedBlockImpl : public CatChainReceivedBlock {
                             CatChainReceiver *chain);
   CatChainReceivedBlockImpl(tl_object_ptr<ton_api::catchain_block_dep> block, CatChainReceiver *chain);
 
-  CatChainReceivedBlockImpl(td::uint32 source_id, CatChainSessionId hash, CatChainReceiver *chain);
+  CatChainReceivedBlockImpl(td::uint32 source_id, const CatChainSessionId &hash, CatChainReceiver *chain);
 
  private:
   enum State {
@@ -124,31 +127,28 @@ class CatChainReceivedBlockImpl : public CatChainReceivedBlock {
     bs_delivered,
   } state_ = bs_none;
 
-  void update_deps(CatChainReceivedBlockImpl *block);
+  void update_vt(CatChainReceivedBlockImpl *block);
 
   void add_rev_dep(CatChainReceivedBlockImpl *block);
-  void add_child_dep(CatChainReceivedBlockImpl *block);
 
   void initialize_fork();
-  void on_ready_to_deliver();
 
   td::uint32 fork_id_{0};
   td::uint32 source_id_;
   CatChainReceiver *chain_;
 
-  tl_object_ptr<ton_api::catchain_block_inner_Data> data_;
   td::SharedSlice payload_;
 
-  CatChainBlockHash hash_;
-  CatChainBlockPayloadHash data_hash_;
+  CatChainBlockHash block_id_hash_{};
+  CatChainBlockPayloadHash data_payload_hash_{};
 
-  CatChainReceivedBlockImpl *prev_;
+  CatChainReceivedBlockImpl *prev_ = nullptr;
   CatChainBlockHeight height_;
 
   CatChainReceivedBlockImpl *next_ = nullptr;
 
   std::vector<CatChainReceivedBlockImpl *> block_deps_;
-  std::vector<CatChainBlockHeight> deps_;
+  std::vector<CatChainBlockHeight> vt_;
 
   td::SharedSlice signature_;
 

catchain/catchain-receiver-interface.h

@@ -35,33 +35,34 @@ class CatChainReceiverInterface : public td::actor::Actor {
                            CatChainBlockHash prev, std::vector<CatChainBlockHash> deps,
                            std::vector<CatChainBlockHeight> vt, td::SharedSlice data) = 0;
     virtual void blame(td::uint32 src_id) = 0;
-    virtual void on_custom_message(PublicKeyHash src, td::BufferSlice data) = 0;
-    virtual void on_custom_query(PublicKeyHash src, td::BufferSlice data, td::Promise<td::BufferSlice> promise) = 0;
-    virtual void on_broadcast(PublicKeyHash src, td::BufferSlice data) = 0;
+    virtual void on_custom_query(const PublicKeyHash &src, td::BufferSlice data,
+                                 td::Promise<td::BufferSlice> promise) = 0;
+    virtual void on_broadcast(const PublicKeyHash &src, td::BufferSlice data) = 0;
     virtual void start() = 0;
     virtual ~Callback() = default;
   };
   virtual void add_block(td::BufferSlice payload, std::vector<CatChainBlockHash> deps) = 0;
   virtual void debug_add_fork(td::BufferSlice payload, CatChainBlockHeight height,
                               std::vector<CatChainBlockHash> deps) = 0;
-  virtual void blame_node(td::uint32 idx) = 0;
   virtual void send_fec_broadcast(td::BufferSlice data) = 0;
-  virtual void send_custom_query_data(PublicKeyHash dst, std::string name, td::Promise<td::BufferSlice> promise,
+  virtual void send_custom_query_data(const PublicKeyHash &dst, std::string name, td::Promise<td::BufferSlice> promise,
                                       td::Timestamp timeout, td::BufferSlice query) = 0;
-  virtual void send_custom_query_data_via(PublicKeyHash dst, std::string name, td::Promise<td::BufferSlice> promise,
-                                          td::Timestamp timeout, td::BufferSlice query, td::uint64 max_answer_size,
+  virtual void send_custom_query_data_via(const PublicKeyHash &dst, std::string name,
+                                          td::Promise<td::BufferSlice> promise, td::Timestamp timeout,
+                                          td::BufferSlice query, td::uint64 max_answer_size,
                                           td::actor::ActorId<adnl::AdnlSenderInterface> via) = 0;
-  virtual void send_custom_message_data(PublicKeyHash dst, td::BufferSlice query) = 0;
+  virtual void send_custom_message_data(const PublicKeyHash &dst, td::BufferSlice query) = 0;
+  virtual void on_blame_processed(td::uint32 source_id) = 0;
 
   virtual void destroy() = 0;
 
   static td::actor::ActorOwn<CatChainReceiverInterface> create(
-      std::unique_ptr<Callback> callback, CatChainOptions opts, td::actor::ActorId<keyring::Keyring> keyring,
+      std::unique_ptr<Callback> callback, const CatChainOptions &opts, td::actor::ActorId<keyring::Keyring> keyring,
       td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<overlay::Overlays> overlay_manager,
-      std::vector<CatChainNode> ids, PublicKeyHash local_id, CatChainSessionId unique_hash, std::string db_root,
-      std::string db_suffix, bool allow_unsafe_self_blocks_resync);
+      const std::vector<CatChainNode> &ids, const PublicKeyHash &local_id, const CatChainSessionId &unique_hash,
+      std::string db_root, std::string db_suffix, bool allow_unsafe_self_blocks_resync);
 
-  virtual ~CatChainReceiverInterface() = default;
+  ~CatChainReceiverInterface() override = default;
 };
 
 }  // namespace catchain

catchain/catchain-receiver-source.cpp

@@ -24,10 +24,10 @@ namespace ton {
 namespace catchain {
 
 td::uint32 CatChainReceiverSourceImpl::add_fork() {
-  if (fork_ids_.size() > 0) {
+  if (!fork_ids_.empty()) {
     blame();
   }
-  auto F = chain_->add_fork();
+  td::uint32 F = chain_->add_fork();
   CHECK(F > 0);
 
   fork_ids_.push_back(F);
@@ -60,15 +60,15 @@ td::Result<std::unique_ptr<CatChainReceiverSource>> CatChainReceiverSource::crea
 
 void CatChainReceiverSourceImpl::blame(td::uint32 fork, CatChainBlockHeight height) {
   blame();
-  if (blamed_heights_.size() > 0) {
-    if (blamed_heights_.size() <= fork) {
-      blamed_heights_.resize(fork + 1, 0);
-    }
-    if (blamed_heights_[fork] == 0 || blamed_heights_[fork] > height) {
-      VLOG(CATCHAIN_INFO) << this << ": blamed at " << fork << " " << height;
-      blamed_heights_[fork] = height;
-    }
+  // if (!blamed_heights_.empty()) {
+  if (blamed_heights_.size() <= fork) {
+    blamed_heights_.resize(fork + 1, 0);
   }
+  if (blamed_heights_[fork] == 0 || blamed_heights_[fork] > height) {
+    VLOG(CATCHAIN_INFO) << this << ": blamed at " << fork << " " << height;
+    blamed_heights_[fork] = height;
+  }
+  // }
 }
 
 void CatChainReceiverSourceImpl::blame() {
@@ -130,19 +130,6 @@ void CatChainReceiverSourceImpl::block_delivered(CatChainBlockHeight height) {
   }
 }
 
-td::Status CatChainReceiverSourceImpl::validate_dep_sync(tl_object_ptr<ton_api::catchain_block_dep> &dep) {
-  auto S = std::move(dep->signature_);
-  auto str = serialize_tl_object(dep, true);
-  dep->signature_ = std::move(S);
-
-  auto R = encryptor_sync_->check_signature(str.as_slice(), dep->signature_.as_slice());
-  if (R.is_error()) {
-    return R.move_as_error();
-  }
-
-  return td::Status::OK();
-}
-
 void CatChainReceiverSourceImpl::on_new_block(CatChainReceivedBlock *block) {
   if (fork_is_found()) {
     return;
@@ -157,7 +144,7 @@ void CatChainReceiverSourceImpl::on_new_block(CatChainReceivedBlock *block) {
       on_found_fork_proof(create_serialize_tl_object<ton_api::catchain_block_data_fork>(block->export_tl_dep(),
                                                                                         it->second->export_tl_dep())
                               .as_slice());
-      chain_->add_prepared_event(fork_proof());
+      chain_->on_found_fork_proof(id_, fork_proof());
     }
     blame();
     return;
@@ -165,7 +152,7 @@ void CatChainReceiverSourceImpl::on_new_block(CatChainReceivedBlock *block) {
   blocks_[block->get_height()] = block;
 }
 
-void CatChainReceiverSourceImpl::on_found_fork_proof(td::Slice proof) {
+void CatChainReceiverSourceImpl::on_found_fork_proof(const td::Slice &proof) {
   if (!fork_is_found()) {
     fetch_tl_object<ton_api::catchain_block_data_fork>(proof, true).ensure();
     fork_proof_ = td::SharedSlice{proof};
@@ -175,6 +162,15 @@ void CatChainReceiverSourceImpl::on_found_fork_proof(td::Slice proof) {
   }
 }
 
+bool CatChainReceiverSourceImpl::allow_send_block(CatChainBlockHash hash) {
+  td::uint32 count = ++block_requests_count_[hash];
+  if (count > MAX_BLOCK_REQUESTS) {
+    VLOG(CATCHAIN_INFO) << this << ": node requested block " << hash << " " << count << " times";
+    return false;
+  }
+  return true;
+}
+
 }  // namespace catchain
 
 }  // namespace ton

catchain/catchain-receiver-source.h

@@ -56,12 +56,14 @@ class CatChainReceiverSource {
   virtual bool has_unreceived() const = 0;
   virtual bool has_undelivered() const = 0;
 
-  virtual td::Status validate_dep_sync(tl_object_ptr<ton_api::catchain_block_dep> &dep) = 0;
   virtual void on_new_block(CatChainReceivedBlock *block) = 0;
-  virtual void on_found_fork_proof(td::Slice fork) = 0;
+  virtual void on_found_fork_proof(const td::Slice &fork) = 0;
   virtual td::BufferSlice fork_proof() const = 0;
   virtual bool fork_is_found() const = 0;
 
+  // One block can be sent to one node in catchain.getDifference only a limited number of times to prevent DoS
+  virtual bool allow_send_block(CatChainBlockHash hash) = 0;
+
   static td::Result<std::unique_ptr<CatChainReceiverSource>> create(CatChainReceiver *chain, PublicKey pub_key,
                                                                     adnl::AdnlNodeIdShort adnl_id, td::uint32 id);
 

catchain/catchain-receiver-source.hpp

@@ -23,6 +23,7 @@
 #include "catchain-receiver-source.h"
 #include "catchain-receiver.h"
 #include "catchain-received-block.h"
+#include <queue>
 
 namespace ton {
 
@@ -82,7 +83,7 @@ class CatChainReceiverSourceImpl : public CatChainReceiverSource {
     if (blamed()) {
       return true;
     }
-    if (!blocks_.size()) {
+    if (blocks_.empty()) {
       return false;
     }
     CHECK(blocks_.rbegin()->second->get_height() >= received_height_);
@@ -93,9 +94,8 @@ class CatChainReceiverSourceImpl : public CatChainReceiverSource {
   }
   CatChainReceivedBlock *get_block(CatChainBlockHeight height) const override;
 
-  td::Status validate_dep_sync(tl_object_ptr<ton_api::catchain_block_dep> &dep) override;
   void on_new_block(CatChainReceivedBlock *block) override;
-  void on_found_fork_proof(td::Slice proof) override;
+  void on_found_fork_proof(const td::Slice &proof) override;
   bool fork_is_found() const override {
     return !fork_proof_.empty();
   }
@@ -103,7 +103,7 @@ class CatChainReceiverSourceImpl : public CatChainReceiverSource {
     if (!fork_proof_.empty()) {
       return fork_proof_.clone_as_buffer_slice();
     } else {
-      return td::BufferSlice();
+      return {};
     }
   }
 
@@ -111,6 +111,8 @@ class CatChainReceiverSourceImpl : public CatChainReceiverSource {
     return chain_;
   }
 
+  bool allow_send_block(CatChainBlockHash hash) override;
+
   CatChainReceiverSourceImpl(CatChainReceiver *chain, PublicKey source, adnl::AdnlNodeIdShort adnl_id, td::uint32 id);
 
  private:
@@ -130,6 +132,11 @@ class CatChainReceiverSourceImpl : public CatChainReceiverSource {
 
   CatChainBlockHeight delivered_height_ = 0;
   CatChainBlockHeight received_height_ = 0;
+
+  std::map<CatChainBlockHash, td::uint32> block_requests_count_;
+  // One block can be sent to one node up to 5 times
+
+  static const td::uint32 MAX_BLOCK_REQUESTS = 5;
 };
 
 }  // namespace catchain