diff --git a/lib/ain-cpp-imports/build.rs b/lib/ain-cpp-imports/build.rs
index 96065f6056..eba3123a7d 100644
--- a/lib/ain-cpp-imports/build.rs
+++ b/lib/ain-cpp-imports/build.rs
@@ -21,7 +21,7 @@ fn main() {
         lib_path.to_str().unwrap()
     );
     println!(
-        "cargo:rerun-if-changed={}/masternodes/ffi_exports.h",
+        "cargo:rerun-if-changed={}/ffi/ffiexports.h",
         lib_path.to_str().unwrap()
     );
 }
diff --git a/lib/ain-cpp-imports/src/lib.rs b/lib/ain-cpp-imports/src/lib.rs
index 408d1126ec..c7786c7d66 100644
--- a/lib/ain-cpp-imports/src/lib.rs
+++ b/lib/ain-cpp-imports/src/lib.rs
@@ -3,10 +3,11 @@ use std::error::Error;
 #[cxx::bridge]
 mod ffi {
     unsafe extern "C++" {
-        include!("masternodes/ffi_exports.h");
+        include!("ffi/ffiexports.h");
 
         fn getChainId() -> u64;
         fn isMining() -> bool;
+        fn publishEthTransaction(data: Vec<u8>) -> bool;
     }
 }
 
@@ -19,3 +20,8 @@ pub fn is_mining() -> Result<bool, Box<dyn Error>> {
     let is_mining = ffi::isMining();
     Ok(is_mining)
 }
+
+pub fn publish_eth_transaction(data: Vec<u8>) -> Result<bool, Box<dyn Error>> {
+    let publish = ffi::publishEthTransaction(data);
+    Ok(publish)
+}
diff --git a/lib/ain-grpc/src/rpc.rs b/lib/ain-grpc/src/rpc.rs
index ae7f188ba3..e313c51068 100644
--- a/lib/ain-grpc/src/rpc.rs
+++ b/lib/ain-grpc/src/rpc.rs
@@ -7,10 +7,11 @@ use crate::codegen::rpc::{
         EthGetBlockTransactionCountByNumberResult, EthGetCodeInput, EthGetCodeResult,
         EthGetStorageAtInput, EthGetStorageAtResult, EthGetTransactionByBlockHashAndIndexInput,
         EthGetTransactionByBlockNumberAndIndexInput, EthGetTransactionByHashInput, EthMiningResult,
-        EthTransactionInfo,
+        EthSendRawTransactionInput, EthSendRawTransactionResult, EthTransactionInfo,
     },
     EthService,
 };
+use ain_cpp_imports::publish_eth_transaction;
 use ain_evm::handler::Handlers;
 use primitive_types::{H256, U256};
 use std::convert::Into;
@@ -85,6 +86,11 @@ pub trait EthServiceApi {
         handler: Arc<Handlers>,
         input: EthGetStorageAtInput,
     ) -> Result<EthGetStorageAtResult, jsonrpsee_core::Error>;
+
+    fn Eth_SendRawTransaction(
+        handler: Arc<Handlers>,
+        input: EthSendRawTransactionInput,
+    ) -> Result<EthSendRawTransactionResult, jsonrpsee_core::Error>;
 }
 
 #[allow(non_snake_case)]
@@ -307,4 +313,20 @@ impl EthServiceApi for EthService {
             value: format!("{:#x}", value),
         })
     }
+
+    fn Eth_SendRawTransaction(
+        _handler: Arc<Handlers>,
+        input: EthSendRawTransactionInput,
+    ) -> Result<EthSendRawTransactionResult, jsonrpsee_core::Error> {
+        let EthSendRawTransactionInput { transaction } = input;
+
+        let hex = hex::decode(transaction).expect("Invalid transaction");
+        let stat = publish_eth_transaction(hex).unwrap();
+
+        println!("{stat}");
+
+        Ok(EthSendRawTransactionResult {
+            hash: format!("{stat}"),
+        })
+    }
 }
diff --git a/lib/proto/rpc/eth.proto b/lib/proto/rpc/eth.proto
index 0e8b6a2aea..73ecaa02db 100644
--- a/lib/proto/rpc/eth.proto
+++ b/lib/proto/rpc/eth.proto
@@ -46,4 +46,6 @@ service eth {
   rpc Eth_GetCode(types.EthGetCodeInput) returns (types.EthGetCodeResult);
 
   rpc Eth_GetStorageAt(types.EthGetStorageAtInput) returns (types.EthGetStorageAtResult);
+
+  rpc Eth_SendRawTransaction(types.EthSendRawTransactionInput) returns (types.EthSendRawTransactionResult);
 }
diff --git a/src/Makefile.am b/src/Makefile.am
index 6ba1a65dae..8c354af77e 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -155,6 +155,7 @@ DEFI_CORE_H = \
   dbwrapper.h \
   limitedmap.h \
   logging.h \
+  ffi/ffiexports.h \
   masternodes/accounts.h \
   masternodes/accountshistory.h \
   masternodes/anchors.h \
@@ -164,7 +165,6 @@ DEFI_CORE_H = \
   masternodes/communityaccounttypes.h \
   masternodes/errors.h \
   masternodes/evm.h \
-  masternodes/ffi_exports.h \
   masternodes/factory.h \
   masternodes/govvariables/attributes.h \
   masternodes/govvariables/icx_takerfee_per_btc.h \
@@ -392,11 +392,11 @@ libdefi_server_a_SOURCES = \
   interfaces/chain.cpp \
   init.cpp \
   dbwrapper.cpp \
+  ffi/ffiexports.cpp \
   masternodes/accounts.cpp \
   masternodes/accountshistory.cpp \
   masternodes/anchors.cpp \
   masternodes/auctionhistory.cpp \
-  masternodes/ffi_exports.cpp \
   masternodes/govvariables/attributes.cpp \
   masternodes/govvariables/icx_takerfee_per_btc.cpp \
   masternodes/govvariables/loan_daily_reward.cpp \
diff --git a/src/ffi/cxx.h b/src/ffi/cxx.h
new file mode 100644
index 0000000000..501bf23a70
--- /dev/null
+++ b/src/ffi/cxx.h
@@ -0,0 +1,1111 @@
+#pragma once
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <initializer_list>
+#include <iosfwd>
+#include <iterator>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#if defined(_WIN32)
+#include <basetsd.h>
+#else
+#include <sys/types.h>
+#endif
+
+namespace rust {
+    inline namespace cxxbridge1 {
+
+        struct unsafe_bitcopy_t;
+
+        namespace {
+            template <typename T>
+            class impl;
+        }
+
+#ifndef CXXBRIDGE1_RUST_STRING
+#define CXXBRIDGE1_RUST_STRING
+// https://cxx.rs/binding/string.html
+        class String final {
+        public:
+            String() noexcept;
+            String(const String &) noexcept;
+            String(String &&) noexcept;
+            ~String() noexcept;
+
+            String(const std::string &);
+            String(const char *);
+            String(const char *, std::size_t);
+            String(const char16_t *);
+            String(const char16_t *, std::size_t);
+
+            // Replace invalid Unicode data with the replacement character (U+FFFD).
+            static String lossy(const std::string &) noexcept;
+            static String lossy(const char *) noexcept;
+            static String lossy(const char *, std::size_t) noexcept;
+            static String lossy(const char16_t *) noexcept;
+            static String lossy(const char16_t *, std::size_t) noexcept;
+
+            String &operator=(const String &) &noexcept;
+            String &operator=(String &&) &noexcept;
+
+            explicit operator std::string() const;
+
+            // Note: no null terminator.
+            const char *data() const noexcept;
+            std::size_t size() const noexcept;
+            std::size_t length() const noexcept;
+            bool empty() const noexcept;
+
+            const char *c_str() noexcept;
+
+            std::size_t capacity() const noexcept;
+            void reserve(size_t new_cap) noexcept;
+
+            using iterator = char *;
+            iterator begin() noexcept;
+            iterator end() noexcept;
+
+            using const_iterator = const char *;
+            const_iterator begin() const noexcept;
+            const_iterator end() const noexcept;
+            const_iterator cbegin() const noexcept;
+            const_iterator cend() const noexcept;
+
+            bool operator==(const String &) const noexcept;
+            bool operator!=(const String &) const noexcept;
+            bool operator<(const String &) const noexcept;
+            bool operator<=(const String &) const noexcept;
+            bool operator>(const String &) const noexcept;
+            bool operator>=(const String &) const noexcept;
+
+            void swap(String &) noexcept;
+
+            // Internal API only intended for the cxxbridge code generator.
+            String(unsafe_bitcopy_t, const String &) noexcept;
+
+        private:
+            struct lossy_t;
+            String(lossy_t, const char *, std::size_t) noexcept;
+            String(lossy_t, const char16_t *, std::size_t) noexcept;
+            friend void swap(String &lhs, String &rhs) noexcept { lhs.swap(rhs); }
+
+            // Size and alignment statically verified by rust_string.rs.
+            std::array<std::uintptr_t, 3> repr;
+        };
+#endif // CXXBRIDGE1_RUST_STRING
+
+#ifndef CXXBRIDGE1_RUST_STR
+#define CXXBRIDGE1_RUST_STR
+// https://cxx.rs/binding/str.html
+        class Str final {
+        public:
+            Str() noexcept;
+            Str(const String &) noexcept;
+            Str(const std::string &);
+            Str(const char *);
+            Str(const char *, std::size_t);
+
+            Str &operator=(const Str &) &noexcept = default;
+
+            explicit operator std::string() const;
+
+            // Note: no null terminator.
+            const char *data() const noexcept;
+            std::size_t size() const noexcept;
+            std::size_t length() const noexcept;
+            bool empty() const noexcept;
+
+            // Important in order for System V ABI to pass in registers.
+            Str(const Str &) noexcept = default;
+            ~Str() noexcept = default;
+
+            using iterator = const char *;
+            using const_iterator = const char *;
+            const_iterator begin() const noexcept;
+            const_iterator end() const noexcept;
+            const_iterator cbegin() const noexcept;
+            const_iterator cend() const noexcept;
+
+            bool operator==(const Str &) const noexcept;
+            bool operator!=(const Str &) const noexcept;
+            bool operator<(const Str &) const noexcept;
+            bool operator<=(const Str &) const noexcept;
+            bool operator>(const Str &) const noexcept;
+            bool operator>=(const Str &) const noexcept;
+
+            void swap(Str &) noexcept;
+
+        private:
+            class uninit;
+            Str(uninit) noexcept;
+            friend impl<Str>;
+
+            std::array<std::uintptr_t, 2> repr;
+        };
+#endif // CXXBRIDGE1_RUST_STR
+
+#ifndef CXXBRIDGE1_RUST_SLICE
+        namespace detail {
+            template <bool>
+            struct copy_assignable_if {};
+
+            template <>
+            struct copy_assignable_if<false> {
+                copy_assignable_if() noexcept = default;
+                copy_assignable_if(const copy_assignable_if &) noexcept = default;
+                copy_assignable_if &operator=(const copy_assignable_if &) &noexcept = delete;
+                copy_assignable_if &operator=(copy_assignable_if &&) &noexcept = default;
+            };
+        } // namespace detail
+
+// https://cxx.rs/binding/slice.html
+        template <typename T>
+        class Slice final
+                : private detail::copy_assignable_if<std::is_const<T>::value> {
+        public:
+            using value_type = T;
+
+            Slice() noexcept;
+            Slice(T *, std::size_t count) noexcept;
+
+            Slice &operator=(const Slice<T> &) &noexcept = default;
+            Slice &operator=(Slice<T> &&) &noexcept = default;
+
+            T *data() const noexcept;
+            std::size_t size() const noexcept;
+            std::size_t length() const noexcept;
+            bool empty() const noexcept;
+
+            T &operator[](std::size_t n) const noexcept;
+            T &at(std::size_t n) const;
+            T &front() const noexcept;
+            T &back() const noexcept;
+
+            // Important in order for System V ABI to pass in registers.
+            Slice(const Slice<T> &) noexcept = default;
+            ~Slice() noexcept = default;
+
+            class iterator;
+            iterator begin() const noexcept;
+            iterator end() const noexcept;
+
+            void swap(Slice &) noexcept;
+
+        private:
+            class uninit;
+            Slice(uninit) noexcept;
+            friend impl<Slice>;
+            friend void sliceInit(void *, const void *, std::size_t) noexcept;
+            friend void *slicePtr(const void *) noexcept;
+            friend std::size_t sliceLen(const void *) noexcept;
+
+            std::array<std::uintptr_t, 2> repr;
+        };
+
+        template <typename T>
+        class Slice<T>::iterator final {
+        public:
+            using iterator_category = std::random_access_iterator_tag;
+            using value_type = T;
+            using difference_type = std::ptrdiff_t;
+            using pointer = typename std::add_pointer<T>::type;
+            using reference = typename std::add_lvalue_reference<T>::type;
+
+            reference operator*() const noexcept;
+            pointer operator->() const noexcept;
+            reference operator[](difference_type) const noexcept;
+
+            iterator &operator++() noexcept;
+            iterator operator++(int) noexcept;
+            iterator &operator--() noexcept;
+            iterator operator--(int) noexcept;
+
+            iterator &operator+=(difference_type) noexcept;
+            iterator &operator-=(difference_type) noexcept;
+            iterator operator+(difference_type) const noexcept;
+            iterator operator-(difference_type) const noexcept;
+            difference_type operator-(const iterator &) const noexcept;
+
+            bool operator==(const iterator &) const noexcept;
+            bool operator!=(const iterator &) const noexcept;
+            bool operator<(const iterator &) const noexcept;
+            bool operator<=(const iterator &) const noexcept;
+            bool operator>(const iterator &) const noexcept;
+            bool operator>=(const iterator &) const noexcept;
+
+        private:
+            friend class Slice;
+            void *pos;
+            std::size_t stride;
+        };
+#endif // CXXBRIDGE1_RUST_SLICE
+
+#ifndef CXXBRIDGE1_RUST_BOX
+// https://cxx.rs/binding/box.html
+        template <typename T>
+        class Box final {
+        public:
+            using element_type = T;
+            using const_pointer =
+                    typename std::add_pointer<typename std::add_const<T>::type>::type;
+            using pointer = typename std::add_pointer<T>::type;
+
+            Box() = delete;
+            Box(Box &&) noexcept;
+            ~Box() noexcept;
+
+            explicit Box(const T &);
+            explicit Box(T &&);
+
+            Box &operator=(Box &&) &noexcept;
+
+            const T *operator->() const noexcept;
+            const T &operator*() const noexcept;
+            T *operator->() noexcept;
+            T &operator*() noexcept;
+
+            template <typename... Fields>
+            static Box in_place(Fields &&...);
+
+            void swap(Box &) noexcept;
+
+            // Important: requires that `raw` came from an into_raw call. Do not pass a
+            // pointer from `new` or any other source.
+            static Box from_raw(T *) noexcept;
+
+            T *into_raw() noexcept;
+
+            /* Deprecated */ using value_type = element_type;
+
+        private:
+            class uninit;
+            class allocation;
+            Box(uninit) noexcept;
+            void drop() noexcept;
+
+            friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+
+            T *ptr;
+        };
+#endif // CXXBRIDGE1_RUST_BOX
+
+#ifndef CXXBRIDGE1_RUST_VEC
+// https://cxx.rs/binding/vec.html
+        template <typename T>
+        class Vec final {
+        public:
+            using value_type = T;
+
+            Vec() noexcept;
+            Vec(std::initializer_list<T>);
+            Vec(const Vec &);
+            Vec(Vec &&) noexcept;
+            ~Vec() noexcept;
+
+            Vec &operator=(Vec &&) &noexcept;
+            Vec &operator=(const Vec &) &;
+
+            std::size_t size() const noexcept;
+            bool empty() const noexcept;
+            const T *data() const noexcept;
+            T *data() noexcept;
+            std::size_t capacity() const noexcept;
+
+            const T &operator[](std::size_t n) const noexcept;
+            const T &at(std::size_t n) const;
+            const T &front() const noexcept;
+            const T &back() const noexcept;
+
+            T &operator[](std::size_t n) noexcept;
+            T &at(std::size_t n);
+            T &front() noexcept;
+            T &back() noexcept;
+
+            void reserve(std::size_t new_cap);
+            void push_back(const T &value);
+            void push_back(T &&value);
+            template <typename... Args>
+            void emplace_back(Args &&...args);
+            void truncate(std::size_t len);
+            void clear();
+
+            using iterator = typename Slice<T>::iterator;
+            iterator begin() noexcept;
+            iterator end() noexcept;
+
+            using const_iterator = typename Slice<const T>::iterator;
+            const_iterator begin() const noexcept;
+            const_iterator end() const noexcept;
+            const_iterator cbegin() const noexcept;
+            const_iterator cend() const noexcept;
+
+            void swap(Vec &) noexcept;
+
+            // Internal API only intended for the cxxbridge code generator.
+            Vec(unsafe_bitcopy_t, const Vec &) noexcept;
+
+        private:
+            void reserve_total(std::size_t new_cap) noexcept;
+            void set_len(std::size_t len) noexcept;
+            void drop() noexcept;
+
+            friend void swap(Vec &lhs, Vec &rhs) noexcept { lhs.swap(rhs); }
+
+            // Size and alignment statically verified by rust_vec.rs.
+            std::array<std::uintptr_t, 3> repr;
+        };
+#endif // CXXBRIDGE1_RUST_VEC
+
+#ifndef CXXBRIDGE1_RUST_FN
+// https://cxx.rs/binding/fn.html
+        template <typename Signature>
+        class Fn;
+
+        template <typename Ret, typename... Args>
+        class Fn<Ret(Args...)> final {
+        public:
+            Ret operator()(Args... args) const noexcept;
+            Fn operator*() const noexcept;
+
+        private:
+            Ret (*trampoline)(Args..., void *fn) noexcept;
+            void *fn;
+        };
+#endif // CXXBRIDGE1_RUST_FN
+
+#ifndef CXXBRIDGE1_RUST_ERROR
+#define CXXBRIDGE1_RUST_ERROR
+// https://cxx.rs/binding/result.html
+        class Error final : public std::exception {
+        public:
+            Error(const Error &);
+            Error(Error &&) noexcept;
+            ~Error() noexcept override;
+
+            Error &operator=(const Error &) &;
+            Error &operator=(Error &&) &noexcept;
+
+            const char *what() const noexcept override;
+
+        private:
+            Error() noexcept = default;
+            friend impl<Error>;
+            const char *msg;
+            std::size_t len;
+        };
+#endif // CXXBRIDGE1_RUST_ERROR
+
+#ifndef CXXBRIDGE1_RUST_ISIZE
+#define CXXBRIDGE1_RUST_ISIZE
+#if defined(_WIN32)
+        using isize = SSIZE_T;
+#else
+        using isize = ssize_t;
+#endif
+#endif // CXXBRIDGE1_RUST_ISIZE
+
+        std::ostream &operator<<(std::ostream &, const String &);
+        std::ostream &operator<<(std::ostream &, const Str &);
+
+#ifndef CXXBRIDGE1_RUST_OPAQUE
+#define CXXBRIDGE1_RUST_OPAQUE
+// Base class of generated opaque Rust types.
+        class Opaque {
+        public:
+            Opaque() = delete;
+            Opaque(const Opaque &) = delete;
+            ~Opaque() = delete;
+        };
+#endif // CXXBRIDGE1_RUST_OPAQUE
+
+        template <typename T>
+        std::size_t size_of();
+        template <typename T>
+        std::size_t align_of();
+
+// IsRelocatable<T> is used in assertions that a C++ type passed by value
+// between Rust and C++ is soundly relocatable by Rust.
+//
+// There may be legitimate reasons to opt out of the check for support of types
+// that the programmer knows are soundly Rust-movable despite not being
+// recognized as such by the C++ type system due to a move constructor or
+// destructor. To opt out of the relocatability check, do either of the
+// following things in any header used by `include!` in the bridge.
+//
+//      --- if you define the type:
+//      struct MyType {
+//        ...
+//    +   using IsRelocatable = std::true_type;
+//      };
+//
+//      --- otherwise:
+//    + template <>
+//    + struct rust::IsRelocatable<MyType> : std::true_type {};
+        template <typename T>
+        struct IsRelocatable;
+
+        using u8 = std::uint8_t;
+        using u16 = std::uint16_t;
+        using u32 = std::uint32_t;
+        using u64 = std::uint64_t;
+        using usize = std::size_t; // see static asserts in cxx.cc
+        using i8 = std::int8_t;
+        using i16 = std::int16_t;
+        using i32 = std::int32_t;
+        using i64 = std::int64_t;
+        using f32 = float;
+        using f64 = double;
+
+// Snake case aliases for use in code that uses this style for type names.
+        using string = String;
+        using str = Str;
+        template <typename T>
+        using slice = Slice<T>;
+        template <typename T>
+        using box = Box<T>;
+        template <typename T>
+        using vec = Vec<T>;
+        using error = Error;
+        template <typename Signature>
+        using fn = Fn<Signature>;
+        template <typename T>
+        using is_relocatable = IsRelocatable<T>;
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+/// end public API, begin implementation details
+
+#ifndef CXXBRIDGE1_PANIC
+#define CXXBRIDGE1_PANIC
+        template <typename Exception>
+        void panic [[noreturn]] (const char *msg);
+#endif // CXXBRIDGE1_PANIC
+
+#ifndef CXXBRIDGE1_RUST_FN
+#define CXXBRIDGE1_RUST_FN
+        template <typename Ret, typename... Args>
+        Ret Fn<Ret(Args...)>::operator()(Args... args) const noexcept {
+        return (*this->trampoline)(std::forward<Args>(args)..., this->fn);
+    }
+
+    template <typename Ret, typename... Args>
+    Fn<Ret(Args...)> Fn<Ret(Args...)>::operator*() const noexcept {
+    return *this;
+}
+#endif // CXXBRIDGE1_RUST_FN
+
+#ifndef CXXBRIDGE1_RUST_BITCOPY_T
+#define CXXBRIDGE1_RUST_BITCOPY_T
+struct unsafe_bitcopy_t final {
+    explicit unsafe_bitcopy_t() = default;
+};
+#endif // CXXBRIDGE1_RUST_BITCOPY_T
+
+#ifndef CXXBRIDGE1_RUST_BITCOPY
+#define CXXBRIDGE1_RUST_BITCOPY
+constexpr unsafe_bitcopy_t unsafe_bitcopy{};
+#endif // CXXBRIDGE1_RUST_BITCOPY
+
+#ifndef CXXBRIDGE1_RUST_SLICE
+#define CXXBRIDGE1_RUST_SLICE
+template <typename T>
+Slice<T>::Slice() noexcept {
+sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+}
+
+template <typename T>
+Slice<T>::Slice(T *s, std::size_t count) noexcept {
+assert(s != nullptr || count == 0);
+sliceInit(this,
+s == nullptr && count == 0
+? reinterpret_cast<void *>(align_of<T>())
+: const_cast<typename std::remove_const<T>::type *>(s),
+        count);
+}
+
+template <typename T>
+T *Slice<T>::data() const noexcept {
+return reinterpret_cast<T *>(slicePtr(this));
+}
+
+template <typename T>
+std::size_t Slice<T>::size() const noexcept {
+return sliceLen(this);
+}
+
+template <typename T>
+std::size_t Slice<T>::length() const noexcept {
+return this->size();
+}
+
+template <typename T>
+bool Slice<T>::empty() const noexcept {
+return this->size() == 0;
+}
+
+template <typename T>
+T &Slice<T>::operator[](std::size_t n) const noexcept {
+assert(n < this->size());
+auto ptr = static_cast<char *>(slicePtr(this)) + size_of<T>() * n;
+return *reinterpret_cast<T *>(ptr);
+}
+
+template <typename T>
+T &Slice<T>::at(std::size_t n) const {
+    if (n >= this->size()) {
+        panic<std::out_of_range>("rust::Slice index out of range");
+    }
+    return (*this)[n];
+}
+
+template <typename T>
+T &Slice<T>::front() const noexcept {
+assert(!this->empty());
+return (*this)[0];
+}
+
+template <typename T>
+T &Slice<T>::back() const noexcept {
+assert(!this->empty());
+return (*this)[this->size() - 1];
+}
+
+template <typename T>
+typename Slice<T>::iterator::reference
+Slice<T>::iterator::operator*() const noexcept {
+return *static_cast<T *>(this->pos);
+}
+
+template <typename T>
+typename Slice<T>::iterator::pointer
+Slice<T>::iterator::operator->() const noexcept {
+return static_cast<T *>(this->pos);
+}
+
+template <typename T>
+typename Slice<T>::iterator::reference Slice<T>::iterator::operator[](
+        typename Slice<T>::iterator::difference_type n) const noexcept {
+auto ptr = static_cast<char *>(this->pos) + this->stride * n;
+return *reinterpret_cast<T *>(ptr);
+}
+
+template <typename T>
+typename Slice<T>::iterator &Slice<T>::iterator::operator++() noexcept {
+this->pos = static_cast<char *>(this->pos) + this->stride;
+return *this;
+}
+
+template <typename T>
+typename Slice<T>::iterator Slice<T>::iterator::operator++(int) noexcept {
+auto ret = iterator(*this);
+this->pos = static_cast<char *>(this->pos) + this->stride;
+return ret;
+}
+
+template <typename T>
+typename Slice<T>::iterator &Slice<T>::iterator::operator--() noexcept {
+this->pos = static_cast<char *>(this->pos) - this->stride;
+return *this;
+}
+
+template <typename T>
+typename Slice<T>::iterator Slice<T>::iterator::operator--(int) noexcept {
+auto ret = iterator(*this);
+this->pos = static_cast<char *>(this->pos) - this->stride;
+return ret;
+}
+
+template <typename T>
+typename Slice<T>::iterator &Slice<T>::iterator::operator+=(
+        typename Slice<T>::iterator::difference_type n) noexcept {
+this->pos = static_cast<char *>(this->pos) + this->stride * n;
+return *this;
+}
+
+template <typename T>
+typename Slice<T>::iterator &Slice<T>::iterator::operator-=(
+        typename Slice<T>::iterator::difference_type n) noexcept {
+this->pos = static_cast<char *>(this->pos) - this->stride * n;
+return *this;
+}
+
+template <typename T>
+typename Slice<T>::iterator Slice<T>::iterator::operator+(
+        typename Slice<T>::iterator::difference_type n) const noexcept {
+auto ret = iterator(*this);
+ret.pos = static_cast<char *>(this->pos) + this->stride * n;
+return ret;
+}
+
+template <typename T>
+typename Slice<T>::iterator Slice<T>::iterator::operator-(
+        typename Slice<T>::iterator::difference_type n) const noexcept {
+auto ret = iterator(*this);
+ret.pos = static_cast<char *>(this->pos) - this->stride * n;
+return ret;
+}
+
+template <typename T>
+typename Slice<T>::iterator::difference_type
+Slice<T>::iterator::operator-(const iterator &other) const noexcept {
+auto diff = std::distance(static_cast<char *>(other.pos),
+                          static_cast<char *>(this->pos));
+return diff / this->stride;
+}
+
+template <typename T>
+bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
+return this->pos == other.pos;
+}
+
+template <typename T>
+bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
+return this->pos != other.pos;
+}
+
+template <typename T>
+bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
+return this->pos < other.pos;
+}
+
+template <typename T>
+bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
+return this->pos <= other.pos;
+}
+
+template <typename T>
+bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
+return this->pos > other.pos;
+}
+
+template <typename T>
+bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
+return this->pos >= other.pos;
+}
+
+template <typename T>
+typename Slice<T>::iterator Slice<T>::begin() const noexcept {
+iterator it;
+it.pos = slicePtr(this);
+it.stride = size_of<T>();
+return it;
+}
+
+template <typename T>
+typename Slice<T>::iterator Slice<T>::end() const noexcept {
+iterator it = this->begin();
+it.pos = static_cast<char *>(it.pos) + it.stride * this->size();
+return it;
+}
+
+template <typename T>
+void Slice<T>::swap(Slice &rhs) noexcept {
+std::swap(*this, rhs);
+}
+#endif // CXXBRIDGE1_RUST_SLICE
+
+#ifndef CXXBRIDGE1_RUST_BOX
+#define CXXBRIDGE1_RUST_BOX
+template <typename T>
+class Box<T>::uninit {};
+
+template <typename T>
+class Box<T>::allocation {
+    static T *alloc() noexcept;
+    static void dealloc(T *) noexcept;
+
+public:
+    allocation() noexcept : ptr(alloc()) {}
+    ~allocation() noexcept {
+        if (this->ptr) {
+            dealloc(this->ptr);
+        }
+    }
+    T *ptr;
+};
+
+template <typename T>
+Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
+other.ptr = nullptr;
+}
+
+template <typename T>
+Box<T>::Box(const T &val) {
+    allocation alloc;
+    ::new (alloc.ptr) T(val);
+    this->ptr = alloc.ptr;
+    alloc.ptr = nullptr;
+}
+
+template <typename T>
+Box<T>::Box(T &&val) {
+    allocation alloc;
+    ::new (alloc.ptr) T(std::move(val));
+    this->ptr = alloc.ptr;
+    alloc.ptr = nullptr;
+}
+
+template <typename T>
+Box<T>::~Box() noexcept {
+if (this->ptr) {
+this->drop();
+}
+}
+
+template <typename T>
+Box<T> &Box<T>::operator=(Box &&other) &noexcept {
+if (this->ptr) {
+this->drop();
+}
+this->ptr = other.ptr;
+other.ptr = nullptr;
+return *this;
+}
+
+template <typename T>
+const T *Box<T>::operator->() const noexcept {
+return this->ptr;
+}
+
+template <typename T>
+const T &Box<T>::operator*() const noexcept {
+return *this->ptr;
+}
+
+template <typename T>
+T *Box<T>::operator->() noexcept {
+return this->ptr;
+}
+
+template <typename T>
+T &Box<T>::operator*() noexcept {
+return *this->ptr;
+}
+
+template <typename T>
+template <typename... Fields>
+Box<T> Box<T>::in_place(Fields &&...fields) {
+    allocation alloc;
+    auto ptr = alloc.ptr;
+    ::new (ptr) T{std::forward<Fields>(fields)...};
+    alloc.ptr = nullptr;
+    return from_raw(ptr);
+}
+
+template <typename T>
+void Box<T>::swap(Box &rhs) noexcept {
+using std::swap;
+swap(this->ptr, rhs.ptr);
+}
+
+template <typename T>
+Box<T> Box<T>::from_raw(T *raw) noexcept {
+Box box = uninit{};
+box.ptr = raw;
+return box;
+}
+
+template <typename T>
+T *Box<T>::into_raw() noexcept {
+T *raw = this->ptr;
+this->ptr = nullptr;
+return raw;
+}
+
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
+#endif // CXXBRIDGE1_RUST_BOX
+
+#ifndef CXXBRIDGE1_RUST_VEC
+#define CXXBRIDGE1_RUST_VEC
+template <typename T>
+Vec<T>::Vec(std::initializer_list<T> init) : Vec{} {
+    this->reserve_total(init.size());
+    std::move(init.begin(), init.end(), std::back_inserter(*this));
+}
+
+template <typename T>
+Vec<T>::Vec(const Vec &other) : Vec() {
+    this->reserve_total(other.size());
+    std::copy(other.begin(), other.end(), std::back_inserter(*this));
+}
+
+template <typename T>
+Vec<T>::Vec(Vec &&other) noexcept : repr(other.repr) {
+new (&other) Vec();
+}
+
+template <typename T>
+Vec<T>::~Vec() noexcept {
+this->drop();
+}
+
+template <typename T>
+Vec<T> &Vec<T>::operator=(Vec &&other) &noexcept {
+this->drop();
+this->repr = other.repr;
+new (&other) Vec();
+return *this;
+}
+
+template <typename T>
+Vec<T> &Vec<T>::operator=(const Vec &other) & {
+    if (this != &other) {
+        this->drop();
+        new (this) Vec(other);
+    }
+    return *this;
+}
+
+template <typename T>
+bool Vec<T>::empty() const noexcept {
+return this->size() == 0;
+}
+
+template <typename T>
+T *Vec<T>::data() noexcept {
+return const_cast<T *>(const_cast<const Vec<T> *>(this)->data());
+}
+
+template <typename T>
+const T &Vec<T>::operator[](std::size_t n) const noexcept {
+assert(n < this->size());
+auto data = reinterpret_cast<const char *>(this->data());
+return *reinterpret_cast<const T *>(data + n * size_of<T>());
+}
+
+template <typename T>
+const T &Vec<T>::at(std::size_t n) const {
+    if (n >= this->size()) {
+        panic<std::out_of_range>("rust::Vec index out of range");
+    }
+    return (*this)[n];
+}
+
+template <typename T>
+const T &Vec<T>::front() const noexcept {
+assert(!this->empty());
+return (*this)[0];
+}
+
+template <typename T>
+const T &Vec<T>::back() const noexcept {
+assert(!this->empty());
+return (*this)[this->size() - 1];
+}
+
+template <typename T>
+T &Vec<T>::operator[](std::size_t n) noexcept {
+assert(n < this->size());
+auto data = reinterpret_cast<char *>(this->data());
+return *reinterpret_cast<T *>(data + n * size_of<T>());
+}
+
+template <typename T>
+T &Vec<T>::at(std::size_t n) {
+    if (n >= this->size()) {
+        panic<std::out_of_range>("rust::Vec index out of range");
+    }
+    return (*this)[n];
+}
+
+template <typename T>
+T &Vec<T>::front() noexcept {
+assert(!this->empty());
+return (*this)[0];
+}
+
+template <typename T>
+T &Vec<T>::back() noexcept {
+assert(!this->empty());
+return (*this)[this->size() - 1];
+}
+
+template <typename T>
+void Vec<T>::reserve(std::size_t new_cap) {
+    this->reserve_total(new_cap);
+}
+
+template <typename T>
+void Vec<T>::push_back(const T &value) {
+    this->emplace_back(value);
+}
+
+template <typename T>
+void Vec<T>::push_back(T &&value) {
+    this->emplace_back(std::move(value));
+}
+
+template <typename T>
+template <typename... Args>
+void Vec<T>::emplace_back(Args &&...args) {
+    auto size = this->size();
+    this->reserve_total(size + 1);
+    ::new (reinterpret_cast<T *>(reinterpret_cast<char *>(this->data()) +
+                                 size * size_of<T>()))
+            T(std::forward<Args>(args)...);
+    this->set_len(size + 1);
+}
+
+template <typename T>
+void Vec<T>::clear() {
+    this->truncate(0);
+}
+
+template <typename T>
+typename Vec<T>::iterator Vec<T>::begin() noexcept {
+return Slice<T>(this->data(), this->size()).begin();
+}
+
+template <typename T>
+typename Vec<T>::iterator Vec<T>::end() noexcept {
+return Slice<T>(this->data(), this->size()).end();
+}
+
+template <typename T>
+typename Vec<T>::const_iterator Vec<T>::begin() const noexcept {
+return this->cbegin();
+}
+
+template <typename T>
+typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
+return this->cend();
+}
+
+template <typename T>
+typename Vec<T>::const_iterator Vec<T>::cbegin() const noexcept {
+return Slice<const T>(this->data(), this->size()).begin();
+}
+
+template <typename T>
+typename Vec<T>::const_iterator Vec<T>::cend() const noexcept {
+return Slice<const T>(this->data(), this->size()).end();
+}
+
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+using std::swap;
+swap(this->repr, rhs.repr);
+}
+
+// Internal API only intended for the cxxbridge code generator.
+template <typename T>
+Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
+#endif // CXXBRIDGE1_RUST_VEC
+
+#ifndef CXXBRIDGE1_IS_COMPLETE
+#define CXXBRIDGE1_IS_COMPLETE
+namespace detail {
+    namespace {
+        template <typename T, typename = std::size_t>
+        struct is_complete : std::false_type {};
+        template <typename T>
+        struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
+    } // namespace
+} // namespace detail
+#endif // CXXBRIDGE1_IS_COMPLETE
+
+#ifndef CXXBRIDGE1_LAYOUT
+#define CXXBRIDGE1_LAYOUT
+class layout {
+    template <typename T>
+    friend std::size_t size_of();
+    template <typename T>
+    friend std::size_t align_of();
+    template <typename T>
+    static typename std::enable_if<std::is_base_of<Opaque, T>::value,
+            std::size_t>::type
+    do_size_of() {
+        return T::layout::size();
+    }
+    template <typename T>
+    static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
+            std::size_t>::type
+    do_size_of() {
+        return sizeof(T);
+    }
+    template <typename T>
+    static
+    typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
+    size_of() {
+        return do_size_of<T>();
+    }
+    template <typename T>
+    static typename std::enable_if<std::is_base_of<Opaque, T>::value,
+            std::size_t>::type
+    do_align_of() {
+        return T::layout::align();
+    }
+    template <typename T>
+    static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
+            std::size_t>::type
+    do_align_of() {
+        return alignof(T);
+    }
+    template <typename T>
+    static
+    typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
+    align_of() {
+        return do_align_of<T>();
+    }
+};
+
+template <typename T>
+std::size_t size_of() {
+    return layout::size_of<T>();
+}
+
+template <typename T>
+std::size_t align_of() {
+    return layout::align_of<T>();
+}
+#endif // CXXBRIDGE1_LAYOUT
+
+#ifndef CXXBRIDGE1_RELOCATABLE
+#define CXXBRIDGE1_RELOCATABLE
+namespace detail {
+    template <typename... Ts>
+    struct make_void {
+        using type = void;
+    };
+
+    template <typename... Ts>
+    using void_t = typename make_void<Ts...>::type;
+
+    template <typename Void, template <typename...> class, typename...>
+    struct detect : std::false_type {};
+    template <template <typename...> class T, typename... A>
+    struct detect<void_t<T<A...>>, T, A...> : std::true_type {};
+
+    template <template <typename...> class T, typename... A>
+    using is_detected = detect<void, T, A...>;
+
+    template <typename T>
+    using detect_IsRelocatable = typename T::IsRelocatable;
+
+    template <typename T>
+    struct get_IsRelocatable
+            : std::is_same<typename T::IsRelocatable, std::true_type> {};
+} // namespace detail
+
+template <typename T>
+struct IsRelocatable
+        : std::conditional<
+                detail::is_detected<detail::detect_IsRelocatable, T>::value,
+                detail::get_IsRelocatable<T>,
+                std::integral_constant<
+                        bool, std::is_trivially_move_constructible<T>::value &&
+                              std::is_trivially_destructible<T>::value>>::type {};
+#endif // CXXBRIDGE1_RELOCATABLE
+
+} // namespace cxxbridge1
+} // namespace rust
\ No newline at end of file
diff --git a/src/ffi/ffiexports.cpp b/src/ffi/ffiexports.cpp
new file mode 100644
index 0000000000..7783c03e8e
--- /dev/null
+++ b/src/ffi/ffiexports.cpp
@@ -0,0 +1,45 @@
+#include <ffi/ffiexports.h>
+#include <util/system.h>
+#include <masternodes/mn_rpc.h>
+
+uint64_t getChainId() {
+    return Params().GetConsensus().evmChainId;
+}
+
+bool isMining() {
+    return gArgs.GetBoolArg("-gen", false);
+}
+
+bool publishEthTransaction(rust::Vec<uint8_t> rawTransaction) {
+    std::vector<uint8_t> evmTx(rawTransaction.size());
+    std::copy(rawTransaction.begin(), rawTransaction.end(), evmTx.begin());
+    CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    metadata << static_cast<unsigned char>(CustomTxType::EvmTx)
+             << CEvmTxMessage{evmTx};
+
+    CScript scriptMeta;
+    scriptMeta << OP_RETURN << ToByteVector(metadata);
+
+    int targetHeight;
+    {
+        LOCK(cs_main);
+        targetHeight = ::ChainActive().Height() + 1;
+    }
+
+    const auto txVersion = GetTransactionVersion(targetHeight);
+    CMutableTransaction rawTx(txVersion);
+
+    rawTx.vin.resize(2);
+    rawTx.vin[0].scriptSig = CScript() << OP_0;
+    rawTx.vin[1].scriptSig = CScript() << OP_0;
+
+    rawTx.vout.emplace_back(0, scriptMeta);
+
+    // check execution
+    CTransactionRef optAuthTx;
+    execTestTx(CTransaction(rawTx), targetHeight, optAuthTx);
+
+    send(MakeTransactionRef(std::move(rawTx)), optAuthTx)->GetHash().ToString();
+
+    return true;
+}
diff --git a/src/masternodes/ffi_exports.h b/src/ffi/ffiexports.h
similarity index 62%
rename from src/masternodes/ffi_exports.h
rename to src/ffi/ffiexports.h
index 358e574006..f5dad89093 100644
--- a/src/masternodes/ffi_exports.h
+++ b/src/ffi/ffiexports.h
@@ -2,8 +2,10 @@
 #define DEFI_EVM_FFI_H
 
 #include <chainparams.h>
+#include <ffi/cxx.h>
 
 uint64_t getChainId();
 bool isMining();
+bool publishEthTransaction(rust::Vec<uint8_t> rawTransaction);
 
 #endif // DEFI_EVM_FFI_H
diff --git a/src/masternodes/ffi_exports.cpp b/src/masternodes/ffi_exports.cpp
deleted file mode 100644
index 72d84f308b..0000000000
--- a/src/masternodes/ffi_exports.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <masternodes/ffi_exports.h>
-#include <util/system.h>
-
-uint64_t getChainId() {
-    return Params().GetConsensus().evmChainId;
-}
-
-bool isMining() {
-    return gArgs.GetBoolArg("-gen", false);
-}
\ No newline at end of file