From 8d3fa96235387bb4bdf7105aa702a7d47cdb7be0 Mon Sep 17 00:00:00 2001 From: Dmitrii Baranov Date: Fri, 19 Apr 2024 09:51:39 +0000 Subject: [PATCH 01/23] Ni: crosscompilation --- .gitlab-ci.yml | 11 ++++++----- README.md | 4 ++++ build.rs | 41 ++++++++++++++++++++++++++++++----------- 3 files changed, 40 insertions(+), 16 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index a8e52e9..3ff35e3 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -16,7 +16,8 @@ variables: FF_USE_FASTZIP: 1 CACHE_COMPRESSION_LEVEL: "fastest" CARGO_HOME: "${CI_PROJECT_DIR}/.cargo" - RUSTFLAGS: "-D warnings" + RUSTFLAGS: "-D warnings -C target-cpu=znver2" + TARGET_CPU_MARCH: "znver2" cache: key: shared-cache @@ -33,7 +34,7 @@ test-branch: - g++ -v - rm -rf ton - cargo fmt --check - - cargo rustc -- -D warnings + - cargo rustc -- $RUSTFLAGS - cargo test --lib tags: - ston @@ -51,7 +52,7 @@ test-mr: - g++ -v - rm -rf ton - cargo fmt --check - - cargo rustc -- -D warnings + - cargo rustc -- $RUSTFLAGS - cargo test --lib -- --test-threads=1 rules: - if: $CI_PIPELINE_SOURCE == 'merge_request_event' @@ -62,7 +63,7 @@ test-master: stage: test script: - cargo fmt --check - - cargo rustc -- -D warnings + - cargo rustc -- $RUSTFLAGS - cargo test --lib -- --test-threads=1 rules: - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH @@ -81,7 +82,7 @@ release-master: script: - git checkout $CI_BUILD_REF_NAME - cargo fmt --check - - cargo rustc -- -D warnings + - cargo rustc -- $RUSTFLAGS - cargo test --lib -- --test-threads=1 - cargo release release --execute --no-publish --no-confirm - export VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0]["version"]') diff --git a/README.md b/README.md index 92e5275..ebb9252 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,10 @@ Then, in your Rust code, you can import the library with: use tonlib_sys; ``` +## Cross-compilation +In order to cross-compile for specific cpu microachitecture set environment variable `TARGET_CPU_MARCH` to the required. Supported values are listen in https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html + + ## Contributing If you want to contribute to this library, please feel free to open a pull request on GitHub. diff --git a/build.rs b/build.rs index 0dacdf2..db9f4d2 100644 --- a/build.rs +++ b/build.rs @@ -1,10 +1,12 @@ +use std::env; + fn main() { build(); } #[cfg(not(feature = "shared-tonlib"))] fn build() { - use std::{env, process::Command}; + use std::process::Command; if !std::path::Path::new("ton/tonlib").is_dir() { let clone_status = std::process::Command::new("git") @@ -114,12 +116,14 @@ fn build() { env::set_var("LD_LIBRARY_PATH", "lib/x86_64-linux-gnu"); - build_tonlibjson(); - build_emulator(); + let march = env::var("TARGET_CPU_MARCH").unwrap_or_default(); + build_tonlibjson(march.as_str()); + build_emulator(march.as_str()); } -fn build_tonlibjson() { - let dst = cmake::Config::new("ton") +fn build_tonlibjson(march: &str) { + let mut cfg = cmake::Config::new("ton"); + let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-DBUILD_SHARED_LIBS=false") .configure_arg("-DCMAKE_EXE_LINKER_FLAGS=-L/opt/homebrew/lib") @@ -127,11 +131,18 @@ fn build_tonlibjson() { .define("BUILD_SHARED_LIBS", "OFF") .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") + //.args(&rust_cmake_args) .configure_arg("-Wno-dev") .build_target("tonlibjson") .always_configure(true) - .very_verbose(false) - .build(); + .very_verbose(false); + + if !march.is_empty() { + dst = dst + .configure_arg(format!("-DCMAKE_C_FLAGS=-march={}", march)) + .configure_arg(format!("-DCMAKE_CXX_FLAGS=-march={}", march)); + } + let dst = dst.build(); println!("cargo:rustc-link-search=native=/usr/lib/x86_64-linux-gnu"); println!("cargo:rustc-link-search=native=/usr/include"); @@ -242,8 +253,9 @@ fn build_tonlibjson() { println!("cargo:rustc-link-lib=static=tonlibjson_private"); } -fn build_emulator() { - let dst = cmake::Config::new("ton") +fn build_emulator(march: &str) { + let mut cfg = cmake::Config::new("ton"); + let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-Wno-dev") .configure_arg("-Wno-unused") @@ -252,9 +264,16 @@ fn build_emulator() { .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") .build_target("emulator") + //.configure_arg() .always_configure(true) - .very_verbose(false) - .build(); + .very_verbose(false); + + if !march.is_empty() { + dst = dst + .configure_arg(format!("-DCMAKE_C_FLAGS=-march={}", march)) + .configure_arg(format!("-DCMAKE_CXX_FLAGS=-march={}", march)); + } + let dst = dst.build(); println!("cargo:rustc-link-lib=dylib=sodium"); println!("cargo:rustc-link-lib=dylib=secp256k1"); From 43d83e2ad2c8339da3d5472c65cb429b3bc62878 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 00:47:33 +0200 Subject: [PATCH 02/23] NI: rebuild tonlyb-sys only if ton revision or sources are changed --- build.rs | 86 +++++++++++++++++++++++++++++++------------------------- 1 file changed, 47 insertions(+), 39 deletions(-) diff --git a/build.rs b/build.rs index db9f4d2..940c0fa 100644 --- a/build.rs +++ b/build.rs @@ -1,54 +1,64 @@ -use std::env; +use std::path::Path; +use std::{env, fs}; fn main() { build(); } +const TONLIB_REVISION: &str = "25f61dff161b9c76dce0fc62dc51da911a208b68"; +const TON_DIR: &str = "./ton"; + #[cfg(not(feature = "shared-tonlib"))] fn build() { + env::set_var("TONLIB_REVISION", TONLIB_REVISION); + println!("cargo:rerun-if-env-changed=TONLIB_REVISION"); + println!("cargo:rerun-if-changed=build.rs"); + println!("cargo:rerun-if-changed=src"); + use std::process::Command; - if !std::path::Path::new("ton/tonlib").is_dir() { - let clone_status = std::process::Command::new("git") - .args([ - "clone", - "--recurse-submodules", - "https://github.com/ton-blockchain/ton", - "--branch", - "testnet", - ]) + // cleanup tonlib after previous build + if Path::new(TON_DIR).exists() { + let _ = fs::remove_dir_all(TON_DIR); + } + + let clone_status = Command::new("git") + .args([ + "clone", + "--recurse-submodules", + "https://github.com/ton-blockchain/ton", + "--branch", + "testnet", + TON_DIR, + ]) + .status() + .unwrap(); + if clone_status.success() { + let checkout_status = Command::new("git") + .current_dir(TON_DIR) + .args(["checkout", TONLIB_REVISION]) .status() .unwrap(); - if clone_status.success() { - let checkout_status = std::process::Command::new("git") - .current_dir("ton") - .args(["checkout", "25f61dff161b9c76dce0fc62dc51da911a208b68"]) - .status() - .unwrap(); - - if checkout_status.success() { - println!("Cloned and checked out specific commit successfully!"); - } else { - println!("Failed to checkout specific commit!"); - } + + if checkout_status.success() { + println!("Cloned and checked out specific commit successfully!"); } else { - println!("Failed to clone repository!"); - } - if !clone_status.success() { - panic!("Git clone TON repo fail"); - } - let update_submodules_status = std::process::Command::new("git") - .current_dir("./ton") - .args(["submodule", "update", "--init", "--recursive"]) - .status() - .unwrap(); - if !update_submodules_status.success() { - panic!("Git update submodules for TON repo fail"); + println!("Failed to checkout specific commit!"); } + } else { + println!("Failed to clone repository!"); + } + if !clone_status.success() { + panic!("Git clone TON repo fail"); + } + let update_submodules_status = Command::new("git") + .current_dir("./ton") + .args(["submodule", "update", "--init", "--recursive"]) + .status() + .unwrap(); + if !update_submodules_status.success() { + panic!("Git update submodules for TON repo fail"); } - - println!("cargo:rerun-if-changed=ton/CMakeLists.txt"); - println!("cargo:rerun-if-changed=build.rs"); if cfg!(target_os = "macos") { env::set_var("NUM_JOBS", num_cpus::get().to_string()); @@ -240,14 +250,12 @@ fn build_tonlibjson(march: &str) { "cargo:rustc-link-search=native={}/build/emulator", dst.display() ); - println!("cargo:rerun-if-changed={}/build/emulator", dst.display()); println!("cargo:rustc-link-lib=static=emulator_static"); println!( "cargo:rustc-link-search=native={}/build/tonlib", dst.display() ); - println!("cargo:rerun-if-changed={}/build/tonlib", dst.display()); println!("cargo:rustc-link-lib=static=tonlibjson"); println!("cargo:rustc-link-lib=static=tonlib"); println!("cargo:rustc-link-lib=static=tonlibjson_private"); From d42e18a40b65cc96156a63d001e2c6ba61172c21 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 01:18:41 +0200 Subject: [PATCH 03/23] NI: use --depth=1 for clone: ~35sec speed-up --- build.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/build.rs b/build.rs index 940c0fa..1430530 100644 --- a/build.rs +++ b/build.rs @@ -25,10 +25,12 @@ fn build() { let clone_status = Command::new("git") .args([ "clone", - "--recurse-submodules", - "https://github.com/ton-blockchain/ton", "--branch", "testnet", + "--depth", + "1", // get only the latest commit + "--recurse-submodules", // clone submodules as well + "https://github.com/ton-blockchain/ton", TON_DIR, ]) .status() From 44a429108188c32539b129a97e37be2e21403a31 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 01:19:36 +0200 Subject: [PATCH 04/23] NI: use --shallow-submodules for clone: ~40sec speed up --- build.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/build.rs b/build.rs index 1430530..001266c 100644 --- a/build.rs +++ b/build.rs @@ -30,6 +30,7 @@ fn build() { "--depth", "1", // get only the latest commit "--recurse-submodules", // clone submodules as well + "--shallow-submodules", // get only the latest commit of submodules "https://github.com/ton-blockchain/ton", TON_DIR, ]) From 5dfa352c789e7cf43c3552524bcb0ee01066d410 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 01:37:14 +0200 Subject: [PATCH 05/23] NI: use -j {cpu_num} for tonlibjsob: ~110sec speed up --- build.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/build.rs b/build.rs index 001266c..0f18d87 100644 --- a/build.rs +++ b/build.rs @@ -144,7 +144,8 @@ fn build_tonlibjson(march: &str) { .define("BUILD_SHARED_LIBS", "OFF") .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") - //.args(&rust_cmake_args) + .build_arg("-j") + .build_arg(num_cpus::get().to_string()) .configure_arg("-Wno-dev") .build_target("tonlibjson") .always_configure(true) From 96bd49f6385f8b7aa1de13b91cb02d0b9580e9f2 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 01:39:34 +0200 Subject: [PATCH 06/23] NI: use -j {cpu_num} for tonlibjsob: ~4sec speed up --- build.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/build.rs b/build.rs index 0f18d87..7284e92 100644 --- a/build.rs +++ b/build.rs @@ -275,6 +275,8 @@ fn build_emulator(march: &str) { .configure_arg("-Wno-deprecated-declarations") .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") + .build_arg("-j") + .build_arg(num_cpus::get().to_string()) .build_target("emulator") //.configure_arg() .always_configure(true) From 81ed423ba0c80a10c4b603caaf2d3f18bc1d734c Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 10:19:25 +0200 Subject: [PATCH 07/23] NI: use available_parallelism() instead of num_cpus --- Cargo.toml | 3 +-- build.rs | 7 +++---- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index acb9ee3..0eb195b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,11 +12,10 @@ include = [ ] [features] -default = ["cmake", "num_cpus"] +default = ["cmake"] shared-tonlib = [] [dependencies] [build-dependencies] cmake = { version = "0.1", optional = true } -num_cpus = { version = "1", optional = true } diff --git a/build.rs b/build.rs index 7284e92..af93116 100644 --- a/build.rs +++ b/build.rs @@ -1,4 +1,5 @@ use std::path::Path; +use std::thread::available_parallelism; use std::{env, fs}; fn main() { @@ -64,8 +65,6 @@ fn build() { } if cfg!(target_os = "macos") { - env::set_var("NUM_JOBS", num_cpus::get().to_string()); - // OpenSSL let openssl_installed = Command::new("brew") .args(["--prefix", "openssl@3"]) @@ -145,7 +144,7 @@ fn build_tonlibjson(march: &str) { .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") .build_arg("-j") - .build_arg(num_cpus::get().to_string()) + .build_arg(available_parallelism().unwrap().get().to_string()) .configure_arg("-Wno-dev") .build_target("tonlibjson") .always_configure(true) @@ -276,7 +275,7 @@ fn build_emulator(march: &str) { .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") .build_arg("-j") - .build_arg(num_cpus::get().to_string()) + .build_arg(available_parallelism().unwrap().get().to_string()) .build_target("emulator") //.configure_arg() .always_configure(true) From 2c5e9f7359cbdd83f8b58244ecf98fd7800d450c Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 10:43:27 +0200 Subject: [PATCH 08/23] NI: use TON_DIR everywhere --- build.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/build.rs b/build.rs index af93116..8c24d8c 100644 --- a/build.rs +++ b/build.rs @@ -56,7 +56,7 @@ fn build() { panic!("Git clone TON repo fail"); } let update_submodules_status = Command::new("git") - .current_dir("./ton") + .current_dir(TON_DIR) .args(["submodule", "update", "--init", "--recursive"]) .status() .unwrap(); @@ -134,7 +134,7 @@ fn build() { } fn build_tonlibjson(march: &str) { - let mut cfg = cmake::Config::new("ton"); + let mut cfg = cmake::Config::new(TON_DIR); let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-DBUILD_SHARED_LIBS=false") @@ -265,7 +265,7 @@ fn build_tonlibjson(march: &str) { } fn build_emulator(march: &str) { - let mut cfg = cmake::Config::new("ton"); + let mut cfg = cmake::Config::new(TON_DIR); let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-Wno-dev") From 075cf0fb21876eb34e7d7dc4b2d58ee1b5cb1abc Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 23 Apr 2024 11:49:52 +0200 Subject: [PATCH 09/23] NI: review fixes --- build.rs | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/build.rs b/build.rs index 8c24d8c..4236f3d 100644 --- a/build.rs +++ b/build.rs @@ -6,21 +6,21 @@ fn main() { build(); } -const TONLIB_REVISION: &str = "25f61dff161b9c76dce0fc62dc51da911a208b68"; -const TON_DIR: &str = "./ton"; +const TON_MONOREPO_REVISION: &str = "25f61dff161b9c76dce0fc62dc51da911a208b68"; +const TON_MONOREPO_DIR: &str = "./ton"; #[cfg(not(feature = "shared-tonlib"))] fn build() { - env::set_var("TONLIB_REVISION", TONLIB_REVISION); - println!("cargo:rerun-if-env-changed=TONLIB_REVISION"); + env::set_var("TON_MONOREPO_REVISION", TON_MONOREPO_REVISION); + println!("cargo:rerun-if-env-changed=TON_MONOREPO_REVISION"); println!("cargo:rerun-if-changed=build.rs"); println!("cargo:rerun-if-changed=src"); use std::process::Command; // cleanup tonlib after previous build - if Path::new(TON_DIR).exists() { - let _ = fs::remove_dir_all(TON_DIR); + if Path::new(TON_MONOREPO_DIR).exists() { + let _ = fs::remove_dir_all(TON_MONOREPO_DIR); } let clone_status = Command::new("git") @@ -33,14 +33,14 @@ fn build() { "--recurse-submodules", // clone submodules as well "--shallow-submodules", // get only the latest commit of submodules "https://github.com/ton-blockchain/ton", - TON_DIR, + TON_MONOREPO_DIR, ]) .status() .unwrap(); if clone_status.success() { let checkout_status = Command::new("git") - .current_dir(TON_DIR) - .args(["checkout", TONLIB_REVISION]) + .current_dir(TON_MONOREPO_DIR) + .args(["checkout", TON_MONOREPO_DIR]) .status() .unwrap(); @@ -56,7 +56,7 @@ fn build() { panic!("Git clone TON repo fail"); } let update_submodules_status = Command::new("git") - .current_dir(TON_DIR) + .current_dir(TON_MONOREPO_DIR) .args(["submodule", "update", "--init", "--recursive"]) .status() .unwrap(); @@ -134,7 +134,7 @@ fn build() { } fn build_tonlibjson(march: &str) { - let mut cfg = cmake::Config::new(TON_DIR); + let mut cfg = cmake::Config::new(TON_MONOREPO_DIR); let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-DBUILD_SHARED_LIBS=false") @@ -143,6 +143,7 @@ fn build_tonlibjson(march: &str) { .define("BUILD_SHARED_LIBS", "OFF") .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") + // multi-thread build used to fail compilation. Please try comment out next 2 lines if you have build errors .build_arg("-j") .build_arg(available_parallelism().unwrap().get().to_string()) .configure_arg("-Wno-dev") @@ -265,7 +266,7 @@ fn build_tonlibjson(march: &str) { } fn build_emulator(march: &str) { - let mut cfg = cmake::Config::new(TON_DIR); + let mut cfg = cmake::Config::new(TON_MONOREPO_DIR); let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-Wno-dev") @@ -274,6 +275,7 @@ fn build_emulator(march: &str) { .configure_arg("-Wno-deprecated-declarations") .define("PORTABLE", "1") .define("CMAKE_BUILD_TYPE", "Release") + // multi-thread build used to fail compilation. Please try comment out next 2 lines if you have build errors .build_arg("-j") .build_arg(available_parallelism().unwrap().get().to_string()) .build_target("emulator") From 1a97f0d4b36f2b567bc522a7c69ceff4cd2016d2 Mon Sep 17 00:00:00 2001 From: Dmitrii Baranov Date: Wed, 1 May 2024 16:40:54 +0000 Subject: [PATCH 10/23] Upstream 2024.3.3 (#16) --- Cargo.toml | 2 +- build.rs | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 0eb195b..af86e71 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "tonlib-sys" -version = "2024.3.2-dev" +version = "2024.3.5-dev" edition = "2021" description = "Rust bindings for tonlibjson library" license = "MIT" diff --git a/build.rs b/build.rs index 4236f3d..69eb92a 100644 --- a/build.rs +++ b/build.rs @@ -279,7 +279,6 @@ fn build_emulator(march: &str) { .build_arg("-j") .build_arg(available_parallelism().unwrap().get().to_string()) .build_target("emulator") - //.configure_arg() .always_configure(true) .very_verbose(false); From 56daf3e38b004aad885571fffd345ada474ce31c Mon Sep 17 00:00:00 2001 From: Andrey Vasiliev Date: Mon, 6 May 2024 10:04:39 +0000 Subject: [PATCH 11/23] NI: repair old mac build --- build.rs | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/build.rs b/build.rs index 69eb92a..c6546ed 100644 --- a/build.rs +++ b/build.rs @@ -1,4 +1,5 @@ use std::path::Path; +use std::process::Command; use std::thread::available_parallelism; use std::{env, fs}; @@ -16,8 +17,6 @@ fn build() { println!("cargo:rerun-if-changed=build.rs"); println!("cargo:rerun-if-changed=src"); - use std::process::Command; - // cleanup tonlib after previous build if Path::new(TON_MONOREPO_DIR).exists() { let _ = fs::remove_dir_all(TON_MONOREPO_DIR); @@ -138,7 +137,6 @@ fn build_tonlibjson(march: &str) { let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-DBUILD_SHARED_LIBS=false") - .configure_arg("-DCMAKE_EXE_LINKER_FLAGS=-L/opt/homebrew/lib") .define("TON_ONLY_TONLIB", "ON") .define("BUILD_SHARED_LIBS", "OFF") .define("PORTABLE", "1") @@ -151,6 +149,13 @@ fn build_tonlibjson(march: &str) { .always_configure(true) .very_verbose(false); + if cfg!(target_os = "macos") { + let brew_prefix_output = Command::new("brew").arg("--prefix").output().unwrap(); + let brew_prefix = String::from_utf8(brew_prefix_output.stdout).unwrap(); + let lib_arg = format!("-DCMAKE_EXE_LINKER_FLAGS=-L{}/lib", brew_prefix.trim()); + dst = dst.configure_arg(lib_arg) + } + if !march.is_empty() { dst = dst .configure_arg(format!("-DCMAKE_C_FLAGS=-march={}", march)) From ad9c8dec60de102f15731f1732702cb364d101d6 Mon Sep 17 00:00:00 2001 From: Dmitrii Baranov Date: Wed, 8 May 2024 14:34:00 +0000 Subject: [PATCH 12/23] Impl NI: no_avx512 flag added --- Cargo.toml | 1 + README.md | 3 --- build.rs | 51 ++++++++++++++++++++++++++++++++------------------- 3 files changed, 33 insertions(+), 22 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index af86e71..2251e8c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,6 +13,7 @@ include = [ [features] default = ["cmake"] +no_avx512 = [] shared-tonlib = [] [dependencies] diff --git a/README.md b/README.md index ebb9252..fc060e7 100644 --- a/README.md +++ b/README.md @@ -22,9 +22,6 @@ Then, in your Rust code, you can import the library with: use tonlib_sys; ``` -## Cross-compilation -In order to cross-compile for specific cpu microachitecture set environment variable `TARGET_CPU_MARCH` to the required. Supported values are listen in https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html - ## Contributing diff --git a/build.rs b/build.rs index c6546ed..07e1e95 100644 --- a/build.rs +++ b/build.rs @@ -3,6 +3,8 @@ use std::process::Command; use std::thread::available_parallelism; use std::{env, fs}; +use cmake::Config; + fn main() { build(); } @@ -12,6 +14,8 @@ const TON_MONOREPO_DIR: &str = "./ton"; #[cfg(not(feature = "shared-tonlib"))] fn build() { + #[cfg(feature = "no_avx512")] + disable_avx512_for_rustc(); env::set_var("TON_MONOREPO_REVISION", TON_MONOREPO_REVISION); println!("cargo:rerun-if-env-changed=TON_MONOREPO_REVISION"); println!("cargo:rerun-if-changed=build.rs"); @@ -126,14 +130,12 @@ fn build() { } env::set_var("LD_LIBRARY_PATH", "lib/x86_64-linux-gnu"); - - let march = env::var("TARGET_CPU_MARCH").unwrap_or_default(); - build_tonlibjson(march.as_str()); - build_emulator(march.as_str()); + build_tonlibjson(); + build_emulator(); } -fn build_tonlibjson(march: &str) { - let mut cfg = cmake::Config::new(TON_MONOREPO_DIR); +fn build_tonlibjson() { + let mut cfg = Config::new(TON_MONOREPO_DIR); let mut dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-DBUILD_SHARED_LIBS=false") @@ -149,6 +151,9 @@ fn build_tonlibjson(march: &str) { .always_configure(true) .very_verbose(false); + #[cfg(feature = "no_avx512")] + disable_avx512_for_clang(dst); + if cfg!(target_os = "macos") { let brew_prefix_output = Command::new("brew").arg("--prefix").output().unwrap(); let brew_prefix = String::from_utf8(brew_prefix_output.stdout).unwrap(); @@ -156,11 +161,6 @@ fn build_tonlibjson(march: &str) { dst = dst.configure_arg(lib_arg) } - if !march.is_empty() { - dst = dst - .configure_arg(format!("-DCMAKE_C_FLAGS=-march={}", march)) - .configure_arg(format!("-DCMAKE_CXX_FLAGS=-march={}", march)); - } let dst = dst.build(); println!("cargo:rustc-link-search=native=/usr/lib/x86_64-linux-gnu"); @@ -270,9 +270,9 @@ fn build_tonlibjson(march: &str) { println!("cargo:rustc-link-lib=static=tonlibjson_private"); } -fn build_emulator(march: &str) { - let mut cfg = cmake::Config::new(TON_MONOREPO_DIR); - let mut dst = cfg +fn build_emulator() { + let mut cfg = Config::new(TON_MONOREPO_DIR); + let dst = cfg .configure_arg("-DTON_ONLY_TONLIB=true") .configure_arg("-Wno-dev") .configure_arg("-Wno-unused") @@ -287,11 +287,9 @@ fn build_emulator(march: &str) { .always_configure(true) .very_verbose(false); - if !march.is_empty() { - dst = dst - .configure_arg(format!("-DCMAKE_C_FLAGS=-march={}", march)) - .configure_arg(format!("-DCMAKE_CXX_FLAGS=-march={}", march)); - } + #[cfg(feature = "no_avx512")] + disable_avx512_for_clang(dst); + let dst = dst.build(); println!("cargo:rustc-link-lib=dylib=sodium"); @@ -307,3 +305,18 @@ fn build_emulator(march: &str) { fn build() { println!("cargo:rustc-link-lib=tonlibjson.0.5"); } + +#[cfg(feature = "no_avx512")] +fn disable_avx512_for_clang(dst: &mut Config) -> &mut Config { + dst + .define("CMAKE_C_FLAGS", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .define("CMAKE_CXX_FLAGS", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .define("CMAKE_C_FLAGS_RELEASE", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .define("CMAKE_CXX_FLAGS_RELEASE", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .asmflag("-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") +} + +#[cfg(feature = "no_avx512")] +fn disable_avx512_for_rustc() { + println!("cargo:rustc-env=RUSTFLAGS=-C target-feature=-avx512f,-avx512dq,-avx512cd,-avx512bw,-avx512vl,-avx512ifma,-avx512vbmi,-vpclmulqdq"); +} From 4d4a1b1b889adfdf206e541aa246198b029469e5 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 10 May 2024 10:58:18 +0200 Subject: [PATCH 13/23] Impl #NI: fix avx build for macos --- build.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/build.rs b/build.rs index 07e1e95..036b36d 100644 --- a/build.rs +++ b/build.rs @@ -152,7 +152,7 @@ fn build_tonlibjson() { .very_verbose(false); #[cfg(feature = "no_avx512")] - disable_avx512_for_clang(dst); + disable_avx512_for_gcc(dst); if cfg!(target_os = "macos") { let brew_prefix_output = Command::new("brew").arg("--prefix").output().unwrap(); @@ -288,7 +288,7 @@ fn build_emulator() { .very_verbose(false); #[cfg(feature = "no_avx512")] - disable_avx512_for_clang(dst); + disable_avx512_for_gcc(dst); let dst = dst.build(); @@ -306,13 +306,14 @@ fn build() { println!("cargo:rustc-link-lib=tonlibjson.0.5"); } +// for clang we just ignore unknown instructions #[cfg(feature = "no_avx512")] -fn disable_avx512_for_clang(dst: &mut Config) -> &mut Config { +fn disable_avx512_for_gcc(dst: &mut Config) -> &mut Config { dst - .define("CMAKE_C_FLAGS", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") - .define("CMAKE_CXX_FLAGS", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") - .define("CMAKE_C_FLAGS_RELEASE", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") - .define("CMAKE_CXX_FLAGS_RELEASE", "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .define("CMAKE_C_FLAGS", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .define("CMAKE_CXX_FLAGS", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .define("CMAKE_C_FLAGS_RELEASE", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + .define("CMAKE_CXX_FLAGS_RELEASE", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") .asmflag("-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") } From fc6f02dc7657f93f234546ac61030dcb51bbd509 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 10 May 2024 11:32:28 +0200 Subject: [PATCH 14/23] NI: make no_avx works with gcc --- build.rs | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/build.rs b/build.rs index 036b36d..d64ae2f 100644 --- a/build.rs +++ b/build.rs @@ -309,12 +309,17 @@ fn build() { // for clang we just ignore unknown instructions #[cfg(feature = "no_avx512")] fn disable_avx512_for_gcc(dst: &mut Config) -> &mut Config { - dst - .define("CMAKE_C_FLAGS", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") - .define("CMAKE_CXX_FLAGS", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") - .define("CMAKE_C_FLAGS_RELEASE", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") - .define("CMAKE_CXX_FLAGS_RELEASE", "-Wno-error=unused-command-line-argument -mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") - .asmflag("-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq") + let disable_avx512 = "-mno-avx512f -mno-avx512dq -mno-avx512cd -mno-avx512bw -mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-vpclmulqdq"; + let compiler_flags = format!("-Wno-unused-command-line-argument {}", disable_avx512); + for flag in &[ + "CMAKE_C_FLAGS", + "CMAKE_CXX_FLAGS", + "CMAKE_C_FLAGS_RELEASE", + "CMAKE_CXX_FLAGS_RELEASE", + ] { + dst.define(flag, compiler_flags.as_str()); + } + dst.asmflag(disable_avx512) } #[cfg(feature = "no_avx512")] From cfcd7bc877bb8202b8e1c1aec06ebf8470144814 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 10 May 2024 11:35:24 +0200 Subject: [PATCH 15/23] NI: add job to test build with no_avx --- .gitlab-ci.yml | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 3ff35e3..82a0fcf 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -57,6 +57,17 @@ test-mr: rules: - if: $CI_PIPELINE_SOURCE == 'merge_request_event' +test-mr-no-avx: + tags: + - ston + stage: test + script: + - rm -rf ton + - cargo build --features no_avx512 + rules: + - if: $CI_PIPELINE_SOURCE == 'merge_request_event' + allow_failure: true + test-master: tags: - ston From 08c368d0739a78c2187814a0450dac1f0e1d305e Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 10 May 2024 14:34:55 +0200 Subject: [PATCH 16/23] Impl #NI: push all mac-deps in loop --- build.rs | 73 ++++++++++++++++++++------------------------------------ 1 file changed, 26 insertions(+), 47 deletions(-) diff --git a/build.rs b/build.rs index d64ae2f..f19e5e7 100644 --- a/build.rs +++ b/build.rs @@ -1,3 +1,4 @@ +use std::collections::HashMap; use std::path::Path; use std::process::Command; use std::thread::available_parallelism; @@ -68,56 +69,34 @@ fn build() { } if cfg!(target_os = "macos") { - // OpenSSL - let openssl_installed = Command::new("brew") - .args(["--prefix", "openssl@3"]) - .output() - .unwrap(); - if !openssl_installed.status.success() { - panic!("OpenSSL is not installed. To install: `brew install openssl`"); - } - let openssl = std::str::from_utf8(openssl_installed.stdout.as_slice()) - .unwrap() - .trim(); - - // lz4 - let lz4_installed = Command::new("brew").args(["list", "lz4"]).output().unwrap(); - if !lz4_installed.status.success() { - panic!("liblz4 is not installed. To install: `brew install lz4`"); + if Command::new("brew").args(["-h"]).output().is_err() { + panic!("brew is not available. Please install it to proceed"); } - - // pkgconfig - let pkgconfig_installed = Command::new("brew") - .args(["list", "pkgconfig"]) - .output() - .unwrap(); - if !pkgconfig_installed.status.success() { - panic!("pkg-config is not installed. To install: `brew install pkgconfig`"); + let mut dep_paths = HashMap::new(); + for dep in &["openssl@3", "lz4", "pkgconfig", "libsodium", "secp256k1"] { + let dep_installed = Command::new("brew") + .args(["--prefix", dep]) + .output() + .unwrap(); + if !dep_installed.status.success() { + panic!( + "{} is not installed. To install: `brew install {}`", + dep, dep + ); + } else { + dep_paths.insert( + dep.to_string(), + std::str::from_utf8(dep_installed.stdout.as_slice()) + .unwrap() + .trim() + .to_string(), + ); + } } - // libsodium - let libsodium_installed = Command::new("brew") - .args(["--prefix", "libsodium"]) - .output() - .unwrap(); - if !libsodium_installed.status.success() { - panic!("libsodium is not installed. To install: `brew install libsodium`"); - } - let libsodium = std::str::from_utf8(libsodium_installed.stdout.as_slice()) - .unwrap() - .trim(); - - // secp256k1 - let secp256k1_installed = Command::new("brew") - .args(["--prefix", "secp256k1"]) - .output() - .unwrap(); - if !secp256k1_installed.status.success() { - panic!("secp256k1 is not installed. To install: `brew install secp256k1`"); - } - let secp256k1 = std::str::from_utf8(secp256k1_installed.stdout.as_slice()) - .unwrap() - .trim(); + let openssl = &dep_paths["openssl@3"]; + let libsodium = &dep_paths["libsodium"]; + let secp256k1 = &dep_paths["secp256k1"]; env::set_var("OPENSSL_ROOT_DIR", openssl); env::set_var("OPENSSL_INCLUDE_DIR", format!("{openssl}/include")); From 8d3e09d45ba711ec722c2939b501550659c0bf6a Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 10 May 2024 14:37:55 +0200 Subject: [PATCH 17/23] Impl #NI: add build for arm_m3 in MR pipeline --- .gitlab-ci.yml | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 82a0fcf..067ce51 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -56,6 +56,7 @@ test-mr: - cargo test --lib -- --test-threads=1 rules: - if: $CI_PIPELINE_SOURCE == 'merge_request_event' + interruptible: true test-mr-no-avx: tags: @@ -67,6 +68,39 @@ test-mr-no-avx: rules: - if: $CI_PIPELINE_SOURCE == 'merge_request_event' allow_failure: true + interruptible: true + +.test-mr-arm-m3: + tags: + - arm_m3 + stage: test + rules: + - if: $CI_PIPELINE_SOURCE == 'merge_request_event' + when: manual + allow_failure: true + cache: + key: arm-m3-cache + paths: + - target/ + - .cargo/ + variables: + TARGET_CPU_MARCH: "" + RUSTFLAGS: "-D warnings" + interruptible: true + +test-mr-arm-m3: + extends: .test-mr-arm-m3 + script: + - clang --version + - cargo build + when: always + +test-mr-arm-m3-no-avx: + extends: .test-mr-arm-m3 + script: + - clang --version + - cargo build --features no_avx512 + test-master: tags: From 6f7ee425a2dc385ab485dd68404d917b2f4d8c3f Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 17 May 2024 00:00:55 +0200 Subject: [PATCH 18/23] Impl #NI: support tx_emulator [src + tests] --- src/lib.rs | 18 ++++- src/tx_emulator.rs | 165 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 182 insertions(+), 1 deletion(-) create mode 100644 src/tx_emulator.rs diff --git a/src/lib.rs b/src/lib.rs index c90608b..9ddf52e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,8 +1,10 @@ mod tonlibjson; mod tvm_emulator; +mod tx_emulator; pub use tonlibjson::*; pub use tvm_emulator::*; +pub use tx_emulator::*; #[cfg(test)] mod tests { @@ -21,7 +23,7 @@ mod tests { } #[test] - fn it_creates_emulator() { + fn it_creates_tvm_emulator() { let code = "te6cckECCwEAAe0AART/APSkE/S88sgLAQIBYgIDAgLMBAUCA3pgCQoD79mRDjgEit8GhpgYC42Eit8H0gGADpj+mf9qJofQB9IGpqGEAKqThdRxgamqiq44L5cCSA/SB9AGoYEGhAMGuQ/QAYEogaKCF4BFAqkGQoAn0BLGeLZmZk9qpwQQg97svvKThdcYEakuAB8YEYAmACcYEvgsIH+XhAYHCACT38FCIBuCoQCaoKAeQoAn0BLGeLAOeLZmSRZGWAiXoAegBlgGSQfIA4OmRlgWUD5f/k6DvADGRlgqxniygCfQEJ5bWJZmZkuP2AQA/jYD+gD6QPgoVBIIcFQgE1QUA8hQBPoCWM8WAc8WzMkiyMsBEvQA9ADLAMn5AHB0yMsCygfL/8nQUAjHBfLgShKhA1AkyFAE+gJYzxbMzMntVAH6QDAg1wsBwwCOH4IQ1TJ223CAEMjLBVADzxYi+gISy2rLH8s/yYBC+wCRW+IAMDUVxwXy4En6QDBZyFAE+gJYzxbMzMntVAAuUUPHBfLgSdQwAchQBPoCWM8WzMzJ7VQAfa289qJofQB9IGpqGDYY/BQAuCoQCaoKAeQoAn0BLGeLAOeLZmSRZGWAiXoAegBlgGT8gDg6ZGWBZQPl/+ToQAAfrxb2omh9AH0gamoYP6qQQFEAfwk=\0"; let data = "te6cckECFAEAA3wAAlFwOPUE4QoACAG/b+7lv/B/MjjfQ11sWK3b4LOpS7Bc7BSmJBVmyz5hdQECAEoBaHR0cHM6Ly90YXJhbnRpbmkuZGV2L3N0b24vbW9vbi5qc29uART/APSkE/S88sgLAwIBYgQFAgLMBgcAG6D2BdqJofQB9IH0gahhAgHUCAkCAUgKCwC7CDHAJJfBOAB0NMDAXGwlRNfA/AL4PpA+kAx+gAxcdch+gAx+gAwAtMfghAPin6lUiC6lTE0WfAI4IIQF41FGVIgupYxREQD8AngNYIQWV8HvLqTWfAK4F8EhA/y8IAARPpEMHC68uFNgAgEgDA0CASASEwH1APTP/oA+kAh8AHtRND6APpA+kDUMFE2oVIqxwXy4sEowv/y4sJUNEJwVCATVBQDyFAE+gJYzxYBzxbMySLIywES9AD0AMsAySD5AHB0yMsCygfL/8nQBPpA9AQx+gB3gBjIywVQCM8WcPoCF8trE8yCEBeNRRnIyx8ZgDgP3O1E0PoA+kD6QNQwCNM/+gBRUaAF+kD6QFNbxwVUc21wVCATVBQDyFAE+gJYzxYBzxbMySLIywES9AD0AMsAyfkAcHTIywLKB8v/ydBQDccFHLHy4sMK+gBRqKGCCJiWgIIImJaAErYIoYIImJaAoBihJ+MPJdcLAcMAI4A8QEQCayz9QB/oCIs8WUAbPFiX6AlADzxbJUAXMI5FykXHiUAioE6CCCJiWgKoAggiYloCgoBS88uLFBMmAQPsAECPIUAT6AljPFgHPFszJ7VQAcFJ5oBihghBzYtCcyMsfUjDLP1j6AlAHzxZQB88WyXGAGMjLBSTPFlAG+gIVy2oUzMlx+wAQJBAjAA4QSRA4N18EAHbCALCOIYIQ1TJ223CAEMjLBVAIzxZQBPoCFstqEssfEss/yXL7AJM1bCHiA8hQBPoCWM8WAc8WzMntVADbO1E0PoA+kD6QNQwB9M/+gD6QDBRUaFSSccF8uLBJ8L/8uLCggiYloCqABagFrzy4sOCEHvdl97Iyx8Vyz9QA/oCIs8WAc8WyXGAGMjLBSTPFnD6AstqzMmAQPsAQBPIUAT6AljPFgHPFszJ7VSAAgyAINch7UTQ+gD6QPpA1DAE0x+CEBeNRRlSILqCEHvdl94TuhKx8uLF0z8x+gAwE6BQI8hQBPoCWM8WAc8WzMntVIH++ZZY=\0"; @@ -39,4 +41,18 @@ mod tests { tvm_emulator_destroy(emulator); } } + + #[test] + fn it_creates_tx_emulator() { + // to generate such string: + // let conf = ton_contract_factory.get_config_cell_serial().await?; + // let config_b64 = CString::new(STANDARD.encode(conf))?; + let config_b64 = "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"; + let config_ptr = config_b64.as_ptr(); + unsafe { + let emulator = transaction_emulator_create(config_ptr as *const i8, 2); + assert!(!emulator.is_null()); + transaction_emulator_destroy(emulator); + } + } } diff --git a/src/tx_emulator.rs b/src/tx_emulator.rs new file mode 100644 index 0000000..bc5c5ce --- /dev/null +++ b/src/tx_emulator.rs @@ -0,0 +1,165 @@ +extern "C" { + /** + * @brief Creates TransactionEmulator object + * @param config_params_boc Base64 encoded BoC serialized Config dictionary (Hashmap 32 ^Cell) + * @param vm_log_verbosity Verbosity level of VM log. 0 - log truncated to last 256 characters. 1 - unlimited length log. + * 2 - for each command prints its cell hash and offset. 3 - for each command log prints all stack values. + * @return Pointer to TransactionEmulator or nullptr in case of error + */ + pub fn transaction_emulator_create( + config_params_boc: *const std::os::raw::c_char, + vm_log_verbosity: u32, + ) -> *mut std::os::raw::c_void; + + /** + * @brief Set unixtime for emulation + * @param transaction_emulator Pointer to TransactionEmulator object + * @param unixtime Unix timestamp + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_unixtime( + tx_emulator: *const std::os::raw::c_void, + unix_time: u32, + ) -> bool; + + /** + * @brief Set lt for emulation + * @param transaction_emulator Pointer to TransactionEmulator object + * @param lt Logical time + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_lt( + tx_emulator: *const std::os::raw::c_void, + lt: u64, + ) -> bool; + + /** + * @brief Set rand seed for emulation + * @param transaction_emulator Pointer to TransactionEmulator object + * @param rand_seed_hex Hex string of length 64 + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_rand_seed( + tx_emulator: *const std::os::raw::c_void, + rand_seed_hex: *const std::os::raw::c_char, + ) -> bool; + + /** + * @brief Set ignore_chksig flag for emulation + * @param transaction_emulator Pointer to TransactionEmulator object + * @param ignore_chksig Whether emulation should always succeed on CHKSIG operation + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_ignore_chksig( + tx_emulator: *const std::os::raw::c_void, + ignore_chksig: bool, + ) -> bool; + + /** + * @brief Set ignore_chksig flag for emulation + * @param transaction_emulator Pointer to TransactionEmulator object + * @param ignore_chksig Whether emulation should always succeed on CHKSIG operation + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_config( + tx_emulator: *const std::os::raw::c_void, + config_boc: *const std::os::raw::c_char, + ) -> bool; + + /** + * @brief Set libs for emulation + * @param transaction_emulator Pointer to TransactionEmulator object + * @param libs_boc Base64 encoded BoC serialized shared libraries dictionary (HashmapE 256 ^Cell). + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_libs( + tx_emulator: *const std::os::raw::c_void, + libs_boc: *const std::os::raw::c_char, + ) -> bool; + + /** + * @brief Enable or disable TVM debug primitives + * @param transaction_emulator Pointer to TransactionEmulator object + * @param debug_enabled Whether debug primitives should be enabled or not + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_debug_enabled( + tx_emulator: *const std::os::raw::c_void, + debug_enabled: bool, + ) -> bool; + + /** + * @brief Set tuple of previous blocks (13th element of c7) + * @param transaction_emulator Pointer to TransactionEmulator object + * @param info_boc Base64 encoded BoC serialized TVM tuple (VmStackValue). + * @return true in case of success, false in case of error + */ + pub fn transaction_emulator_set_prev_blocks_info( + tx_emulator: *const std::os::raw::c_void, + info_boc: *const std::os::raw::c_char, + ) -> bool; + + /** + * @brief Emulate transaction + * @param transaction_emulator Pointer to TransactionEmulator object + * @param shard_account_boc Base64 encoded BoC serialized ShardAccount + * @param message_boc Base64 encoded BoC serialized inbound Message (internal or external) + * @return Json object with error: + * { + * "success": false, + * "error": "Error description", + * "external_not_accepted": false, + * // and optional fields "vm_exit_code", "vm_log", "elapsed_time" in case external message was not accepted. + * } + * Or success: + * { + * "success": true, + * "transaction": "Base64 encoded Transaction boc", + * "shard_account": "Base64 encoded new ShardAccount boc", + * "vm_log": "execute DUP...", + * "actions": "Base64 encoded compute phase actions boc (OutList n)", + * "elapsed_time": 0.02 + * } + */ + pub fn transaction_emulator_emulate_transaction( + tx_emulator: *const std::os::raw::c_void, + shard_account_boc: *const std::os::raw::c_char, + message_boc: *const std::os::raw::c_char, + ) -> *const std::os::raw::c_char; + + /** + * @brief Emulate transaction + * @param transaction_emulator Pointer to TransactionEmulator object + * @param shard_account_boc Base64 encoded BoC serialized ShardAccount + * @param message_boc Base64 encoded BoC serialized inbound Message (internal or external) + * @return Json object with error: + * { + * "success": false, + * "error": "Error description", + * "external_not_accepted": false, + * // and optional fields "vm_exit_code", "vm_log", "elapsed_time" in case external message was not accepted. + * } + * Or success: + * { + * "success": true, + * "transaction": "Base64 encoded Transaction boc", + * "shard_account": "Base64 encoded new ShardAccount boc", + * "vm_log": "execute DUP...", + * "actions": "Base64 encoded compute phase actions boc (OutList n)", + * "elapsed_time": 0.02 + * } + */ + pub fn transaction_emulator_emulate_tick_tock_transaction( + tx_emulator: *const std::os::raw::c_void, + shard_account_boc: *const std::os::raw::c_char, + is_tock: bool, + ) -> *const std::os::raw::c_char; + + /** + * @brief Destroy TransactionEmulator object + * @param transaction_emulator Pointer to TransactionEmulator object + */ + pub fn transaction_emulator_destroy( + tx_emulator: *const std::os::raw::c_void, + ); +} \ No newline at end of file From b3de43ce4e13bd0f72b671efaed2cb127293ca56 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 17 May 2024 00:23:02 +0200 Subject: [PATCH 19/23] Impl #NI: put tests to related mods --- src/lib.rs | 51 --------------------------------------------- src/tonlibjson.rs | 32 +++++++++++++++++++--------- src/tvm_emulator.rs | 42 ++++++++++++++++++++++--------------- src/tx_emulator.rs | 35 ++++++++++++++++++++++--------- 4 files changed, 72 insertions(+), 88 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 9ddf52e..616ba58 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,54 +5,3 @@ mod tx_emulator; pub use tonlibjson::*; pub use tvm_emulator::*; pub use tx_emulator::*; - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn it_creates_client() { - unsafe { - let client = tonlib_client_json_create(); - tonlib_client_set_verbosity_level(4); - assert!(!client.is_null()); - tonlib_client_json_send(client, "123\0".as_bytes().as_ptr() as *const i8); - tonlib_client_json_receive(client, 1.0); - tonlib_client_json_destroy(client); - } - } - - #[test] - fn it_creates_tvm_emulator() { - let code = "te6cckECCwEAAe0AART/APSkE/S88sgLAQIBYgIDAgLMBAUCA3pgCQoD79mRDjgEit8GhpgYC42Eit8H0gGADpj+mf9qJofQB9IGpqGEAKqThdRxgamqiq44L5cCSA/SB9AGoYEGhAMGuQ/QAYEogaKCF4BFAqkGQoAn0BLGeLZmZk9qpwQQg97svvKThdcYEakuAB8YEYAmACcYEvgsIH+XhAYHCACT38FCIBuCoQCaoKAeQoAn0BLGeLAOeLZmSRZGWAiXoAegBlgGSQfIA4OmRlgWUD5f/k6DvADGRlgqxniygCfQEJ5bWJZmZkuP2AQA/jYD+gD6QPgoVBIIcFQgE1QUA8hQBPoCWM8WAc8WzMkiyMsBEvQA9ADLAMn5AHB0yMsCygfL/8nQUAjHBfLgShKhA1AkyFAE+gJYzxbMzMntVAH6QDAg1wsBwwCOH4IQ1TJ223CAEMjLBVADzxYi+gISy2rLH8s/yYBC+wCRW+IAMDUVxwXy4En6QDBZyFAE+gJYzxbMzMntVAAuUUPHBfLgSdQwAchQBPoCWM8WzMzJ7VQAfa289qJofQB9IGpqGDYY/BQAuCoQCaoKAeQoAn0BLGeLAOeLZmSRZGWAiXoAegBlgGT8gDg6ZGWBZQPl/+ToQAAfrxb2omh9AH0gamoYP6qQQFEAfwk=\0"; - - let data = "te6cckECFAEAA3wAAlFwOPUE4QoACAG/b+7lv/B/MjjfQ11sWK3b4LOpS7Bc7BSmJBVmyz5hdQECAEoBaHR0cHM6Ly90YXJhbnRpbmkuZGV2L3N0b24vbW9vbi5qc29uART/APSkE/S88sgLAwIBYgQFAgLMBgcAG6D2BdqJofQB9IH0gahhAgHUCAkCAUgKCwC7CDHAJJfBOAB0NMDAXGwlRNfA/AL4PpA+kAx+gAxcdch+gAx+gAwAtMfghAPin6lUiC6lTE0WfAI4IIQF41FGVIgupYxREQD8AngNYIQWV8HvLqTWfAK4F8EhA/y8IAARPpEMHC68uFNgAgEgDA0CASASEwH1APTP/oA+kAh8AHtRND6APpA+kDUMFE2oVIqxwXy4sEowv/y4sJUNEJwVCATVBQDyFAE+gJYzxYBzxbMySLIywES9AD0AMsAySD5AHB0yMsCygfL/8nQBPpA9AQx+gB3gBjIywVQCM8WcPoCF8trE8yCEBeNRRnIyx8ZgDgP3O1E0PoA+kD6QNQwCNM/+gBRUaAF+kD6QFNbxwVUc21wVCATVBQDyFAE+gJYzxYBzxbMySLIywES9AD0AMsAyfkAcHTIywLKB8v/ydBQDccFHLHy4sMK+gBRqKGCCJiWgIIImJaAErYIoYIImJaAoBihJ+MPJdcLAcMAI4A8QEQCayz9QB/oCIs8WUAbPFiX6AlADzxbJUAXMI5FykXHiUAioE6CCCJiWgKoAggiYloCgoBS88uLFBMmAQPsAECPIUAT6AljPFgHPFszJ7VQAcFJ5oBihghBzYtCcyMsfUjDLP1j6AlAHzxZQB88WyXGAGMjLBSTPFlAG+gIVy2oUzMlx+wAQJBAjAA4QSRA4N18EAHbCALCOIYIQ1TJ223CAEMjLBVAIzxZQBPoCFstqEssfEss/yXL7AJM1bCHiA8hQBPoCWM8WAc8WzMntVADbO1E0PoA+kD6QNQwB9M/+gD6QDBRUaFSSccF8uLBJ8L/8uLCggiYloCqABagFrzy4sOCEHvdl97Iyx8Vyz9QA/oCIs8WAc8WyXGAGMjLBSTPFnD6AstqzMmAQPsAQBPIUAT6AljPFgHPFszJ7VSAAgyAINch7UTQ+gD6QPpA1DAE0x+CEBeNRRlSILqCEHvdl94TuhKx8uLF0z8x+gAwE6BQI8hQBPoCWM8WAc8WzMntVIH++ZZY=\0"; - - let code_slice = code.as_bytes(); - let data_slice = data.as_bytes(); - let code_packed = code_slice.as_ptr(); - let data_packed = data_slice.as_ptr(); - - unsafe { - let emulator = - tvm_emulator_create(code_packed as *const i8, data_packed as *const i8, 2); - tvm_emulator_run_get_method(emulator, 11111123, data_packed as *const i8); - assert!(!emulator.is_null()); - tvm_emulator_destroy(emulator); - } - } - - #[test] - fn it_creates_tx_emulator() { - // to generate such string: - // let conf = ton_contract_factory.get_config_cell_serial().await?; - // let config_b64 = CString::new(STANDARD.encode(conf))?; - let config_b64 = "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"; - let config_ptr = config_b64.as_ptr(); - unsafe { - let emulator = transaction_emulator_create(config_ptr as *const i8, 2); - assert!(!emulator.is_null()); - transaction_emulator_destroy(emulator); - } - } -} diff --git a/src/tonlibjson.rs b/src/tonlibjson.rs index 6c5a27e..0492216 100644 --- a/src/tonlibjson.rs +++ b/src/tonlibjson.rs @@ -1,27 +1,39 @@ extern "C" { pub fn tonlib_client_json_create() -> *mut ::std::os::raw::c_void; -} -extern "C" { + pub fn tonlib_client_json_send( client: *mut ::std::os::raw::c_void, request: *const ::std::os::raw::c_char, ); -} -extern "C" { + pub fn tonlib_client_json_receive( client: *mut ::std::os::raw::c_void, timeout: f64, ) -> *const ::std::os::raw::c_char; -} -extern "C" { + pub fn tonlib_client_json_execute( client: *mut ::std::os::raw::c_void, request: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char; -} -extern "C" { + pub fn tonlib_client_json_destroy(client: *mut ::std::os::raw::c_void); -} -extern "C" { + pub fn tonlib_client_set_verbosity_level(verbosity_level: u32); } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_creates_client() { + unsafe { + let client = tonlib_client_json_create(); + tonlib_client_set_verbosity_level(4); + assert!(!client.is_null()); + tonlib_client_json_send(client, "123\0".as_bytes().as_ptr() as *const i8); + tonlib_client_json_receive(client, 1.0); + tonlib_client_json_destroy(client); + } + } +} diff --git a/src/tvm_emulator.rs b/src/tvm_emulator.rs index de6a2e7..15c8fa0 100644 --- a/src/tvm_emulator.rs +++ b/src/tvm_emulator.rs @@ -11,9 +11,7 @@ extern "C" { data: *const ::std::os::raw::c_char, vm_log_verbosity: u32, ) -> *mut ::std::os::raw::c_void; -} -extern "C" { /** * @brief Set libraries for TVM emulator * @param libs_boc Base64 encoded BoC serialized libraries dictionary (HashmapE 256 ^Cell). @@ -23,9 +21,7 @@ extern "C" { tvm_emulator: *mut ::std::os::raw::c_void, libs_boc: *const ::std::os::raw::c_char, ) -> bool; -} -extern "C" { /** * @brief Set c7 parameters * @param tvm_emulator Pointer to TVM emulator @@ -44,9 +40,7 @@ extern "C" { rand_seed_hex: *const ::std::os::raw::c_char, config: *const ::std::os::raw::c_char, ) -> bool; -} -extern "C" { /** * @brief Set TVM gas limit * @param tvm_emulator Pointer to TVM emulator @@ -57,9 +51,7 @@ extern "C" { tvm_emulator: *mut ::std::os::raw::c_void, gas_limit: u64, ) -> bool; -} -extern "C" { /** * @brief Enable or disable TVM debug primitives * @param tvm_emulator Pointer to TVM emulator @@ -71,9 +63,6 @@ extern "C" { debug_enabled: ::std::os::raw::c_int, ) -> bool; -} - -extern "C" { /** * @brief Run get method * @param tvm_emulator Pointer to TVM emulator @@ -99,9 +88,7 @@ extern "C" { method_id: i32, stack_boc: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char; -} -extern "C" { /** * @brief Send external message * @param tvm_emulator Pointer to TVM emulator @@ -128,9 +115,7 @@ extern "C" { tvm_emulator: *mut ::std::os::raw::c_void, message_body_boc: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char; -} -extern "C" { /** * @brief Send internal message * @param tvm_emulator Pointer to TVM emulator @@ -159,12 +144,35 @@ extern "C" { message_body_boc: *const ::std::os::raw::c_char, amount: u64, ) -> *const ::std::os::raw::c_char; -} -extern "C" { /** * @brief Destroy TVM emulator object * @param tvm_emulator Pointer to TVM emulator object */ pub fn tvm_emulator_destroy(tvm_emulator: *mut ::std::os::raw::c_void); } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_creates_tvm_emulator() { + let code = "te6cckECCwEAAe0AART/APSkE/S88sgLAQIBYgIDAgLMBAUCA3pgCQoD79mRDjgEit8GhpgYC42Eit8H0gGADpj+mf9qJofQB9IGpqGEAKqThdRxgamqiq44L5cCSA/SB9AGoYEGhAMGuQ/QAYEogaKCF4BFAqkGQoAn0BLGeLZmZk9qpwQQg97svvKThdcYEakuAB8YEYAmACcYEvgsIH+XhAYHCACT38FCIBuCoQCaoKAeQoAn0BLGeLAOeLZmSRZGWAiXoAegBlgGSQfIA4OmRlgWUD5f/k6DvADGRlgqxniygCfQEJ5bWJZmZkuP2AQA/jYD+gD6QPgoVBIIcFQgE1QUA8hQBPoCWM8WAc8WzMkiyMsBEvQA9ADLAMn5AHB0yMsCygfL/8nQUAjHBfLgShKhA1AkyFAE+gJYzxbMzMntVAH6QDAg1wsBwwCOH4IQ1TJ223CAEMjLBVADzxYi+gISy2rLH8s/yYBC+wCRW+IAMDUVxwXy4En6QDBZyFAE+gJYzxbMzMntVAAuUUPHBfLgSdQwAchQBPoCWM8WzMzJ7VQAfa289qJofQB9IGpqGDYY/BQAuCoQCaoKAeQoAn0BLGeLAOeLZmSRZGWAiXoAegBlgGT8gDg6ZGWBZQPl/+ToQAAfrxb2omh9AH0gamoYP6qQQFEAfwk=\0"; + + let data = "te6cckECFAEAA3wAAlFwOPUE4QoACAG/b+7lv/B/MjjfQ11sWK3b4LOpS7Bc7BSmJBVmyz5hdQECAEoBaHR0cHM6Ly90YXJhbnRpbmkuZGV2L3N0b24vbW9vbi5qc29uART/APSkE/S88sgLAwIBYgQFAgLMBgcAG6D2BdqJofQB9IH0gahhAgHUCAkCAUgKCwC7CDHAJJfBOAB0NMDAXGwlRNfA/AL4PpA+kAx+gAxcdch+gAx+gAwAtMfghAPin6lUiC6lTE0WfAI4IIQF41FGVIgupYxREQD8AngNYIQWV8HvLqTWfAK4F8EhA/y8IAARPpEMHC68uFNgAgEgDA0CASASEwH1APTP/oA+kAh8AHtRND6APpA+kDUMFE2oVIqxwXy4sEowv/y4sJUNEJwVCATVBQDyFAE+gJYzxYBzxbMySLIywES9AD0AMsAySD5AHB0yMsCygfL/8nQBPpA9AQx+gB3gBjIywVQCM8WcPoCF8trE8yCEBeNRRnIyx8ZgDgP3O1E0PoA+kD6QNQwCNM/+gBRUaAF+kD6QFNbxwVUc21wVCATVBQDyFAE+gJYzxYBzxbMySLIywES9AD0AMsAyfkAcHTIywLKB8v/ydBQDccFHLHy4sMK+gBRqKGCCJiWgIIImJaAErYIoYIImJaAoBihJ+MPJdcLAcMAI4A8QEQCayz9QB/oCIs8WUAbPFiX6AlADzxbJUAXMI5FykXHiUAioE6CCCJiWgKoAggiYloCgoBS88uLFBMmAQPsAECPIUAT6AljPFgHPFszJ7VQAcFJ5oBihghBzYtCcyMsfUjDLP1j6AlAHzxZQB88WyXGAGMjLBSTPFlAG+gIVy2oUzMlx+wAQJBAjAA4QSRA4N18EAHbCALCOIYIQ1TJ223CAEMjLBVAIzxZQBPoCFstqEssfEss/yXL7AJM1bCHiA8hQBPoCWM8WAc8WzMntVADbO1E0PoA+kD6QNQwB9M/+gD6QDBRUaFSSccF8uLBJ8L/8uLCggiYloCqABagFrzy4sOCEHvdl97Iyx8Vyz9QA/oCIs8WAc8WyXGAGMjLBSTPFnD6AstqzMmAQPsAQBPIUAT6AljPFgHPFszJ7VSAAgyAINch7UTQ+gD6QPpA1DAE0x+CEBeNRRlSILqCEHvdl94TuhKx8uLF0z8x+gAwE6BQI8hQBPoCWM8WAc8WzMntVIH++ZZY=\0"; + + let code_slice = code.as_bytes(); + let data_slice = data.as_bytes(); + let code_packed = code_slice.as_ptr(); + let data_packed = data_slice.as_ptr(); + + unsafe { + let emulator = + tvm_emulator_create(code_packed as *const i8, data_packed as *const i8, 2); + tvm_emulator_run_get_method(emulator, 11111123, data_packed as *const i8); + assert!(!emulator.is_null()); + tvm_emulator_destroy(emulator); + } + } +} diff --git a/src/tx_emulator.rs b/src/tx_emulator.rs index bc5c5ce..e8f1337 100644 --- a/src/tx_emulator.rs +++ b/src/tx_emulator.rs @@ -28,10 +28,7 @@ extern "C" { * @param lt Logical time * @return true in case of success, false in case of error */ - pub fn transaction_emulator_set_lt( - tx_emulator: *const std::os::raw::c_void, - lt: u64, - ) -> bool; + pub fn transaction_emulator_set_lt(tx_emulator: *const std::os::raw::c_void, lt: u64) -> bool; /** * @brief Set rand seed for emulation @@ -56,9 +53,9 @@ extern "C" { ) -> bool; /** - * @brief Set ignore_chksig flag for emulation + * @brief Set config for emulation * @param transaction_emulator Pointer to TransactionEmulator object - * @param ignore_chksig Whether emulation should always succeed on CHKSIG operation + * @param config_boc Base64 encoded BoC serialized Config dictionary (Hashmap 32 ^Cell) * @return true in case of success, false in case of error */ pub fn transaction_emulator_set_config( @@ -159,7 +156,25 @@ extern "C" { * @brief Destroy TransactionEmulator object * @param transaction_emulator Pointer to TransactionEmulator object */ - pub fn transaction_emulator_destroy( - tx_emulator: *const std::os::raw::c_void, - ); -} \ No newline at end of file + pub fn transaction_emulator_destroy(tx_emulator: *const std::os::raw::c_void); +} + +#[cfg(test)] +mod tests { + use super::*; + use std::ffi::CString; + + #[test] + fn it_creates_tx_emulator() { + // to generate such string: + // let conf = ton_contract_factory.get_config_cell_serial().await?; + // let config_b64 = STANDARD.encode(conf); + let config_b64 = "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"; + let config_ptr = CString::new(config_b64).unwrap(); + unsafe { + let emulator = transaction_emulator_create(config_ptr.into_raw(), 2); + assert!(!emulator.is_null()); + transaction_emulator_destroy(emulator); + } + } +} From fe6ab262c9c20dfd757e0f047ef2099c6688dad3 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Fri, 17 May 2024 00:24:04 +0200 Subject: [PATCH 20/23] Impl #NI: don't rebuild tonlibs if revision is not changed --- build.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/build.rs b/build.rs index f19e5e7..fa7e094 100644 --- a/build.rs +++ b/build.rs @@ -20,7 +20,6 @@ fn build() { env::set_var("TON_MONOREPO_REVISION", TON_MONOREPO_REVISION); println!("cargo:rerun-if-env-changed=TON_MONOREPO_REVISION"); println!("cargo:rerun-if-changed=build.rs"); - println!("cargo:rerun-if-changed=src"); // cleanup tonlib after previous build if Path::new(TON_MONOREPO_DIR).exists() { From 48de10b6d85e5891a74a830cf54031ad83654779 Mon Sep 17 00:00:00 2001 From: Dmitrii Korchagin Date: Tue, 28 May 2024 12:38:12 +0200 Subject: [PATCH 21/23] Impl #NI: update tick-tock emulation coms --- src/tx_emulator.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/tx_emulator.rs b/src/tx_emulator.rs index e8f1337..7cdc143 100644 --- a/src/tx_emulator.rs +++ b/src/tx_emulator.rs @@ -125,16 +125,15 @@ extern "C" { ) -> *const std::os::raw::c_char; /** - * @brief Emulate transaction + * @brief Emulate tick tock transaction * @param transaction_emulator Pointer to TransactionEmulator object - * @param shard_account_boc Base64 encoded BoC serialized ShardAccount - * @param message_boc Base64 encoded BoC serialized inbound Message (internal or external) + * @param shard_account_boc Base64 encoded BoC serialized ShardAccount of special account + * @param is_tock True for tock transactions, false for tick * @return Json object with error: * { * "success": false, * "error": "Error description", - * "external_not_accepted": false, - * // and optional fields "vm_exit_code", "vm_log", "elapsed_time" in case external message was not accepted. + * "external_not_accepted": false * } * Or success: * { From 4254d8b7df6e81a452b56276121176c417f62f4f Mon Sep 17 00:00:00 2001 From: dbaranov34 Date: Thu, 6 Jun 2024 23:40:40 +0400 Subject: [PATCH 22/23] bump ton to 2024.4 --- build.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/build.rs b/build.rs index d64ae2f..f1b4198 100644 --- a/build.rs +++ b/build.rs @@ -9,7 +9,7 @@ fn main() { build(); } -const TON_MONOREPO_REVISION: &str = "25f61dff161b9c76dce0fc62dc51da911a208b68"; +const TON_MONOREPO_REVISION: &str = "4cfe1d1a96acf956e28e2bbc696a143489e23631"; const TON_MONOREPO_DIR: &str = "./ton"; #[cfg(not(feature = "shared-tonlib"))] @@ -30,7 +30,7 @@ fn build() { .args([ "clone", "--branch", - "testnet", + "v2024.04", "--depth", "1", // get only the latest commit "--recurse-submodules", // clone submodules as well From 8bdc64a5a0ef0272b822796ad08f8c6d045d3d02 Mon Sep 17 00:00:00 2001 From: dbaranov34 Date: Thu, 6 Jun 2024 23:57:04 +0400 Subject: [PATCH 23/23] typo --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 615b706..7a6fde9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "tonlib-sys" -version = "2024.3.0" +version = "2024.4.0" edition = "2021" description = "Rust bindings for tonlibjson library" license = "MIT"