diff --git a/CronosPlayUnreal.uplugin b/CronosPlayUnreal.uplugin
index c8c3eab0..b69508c9 100644
--- a/CronosPlayUnreal.uplugin
+++ b/CronosPlayUnreal.uplugin
@@ -2,8 +2,8 @@
 	"FileVersion": 3,
 	"FriendlyName": "Cronos Play for Unreal Engine",
 	"Version": 1,
-	"VersionName": "v0.0.17-alpha",
-	"EngineVersion": "5.2.0",
+	"VersionName": "v0.0.18-alpha",
+	"EngineVersion": "5.3.0",
 	"Description": "Cronos labs",
 	"Category": "Programming",
 	"CreatedBy": "Cronos labs",
diff --git a/Makefile b/Makefile
index 4f58d3c8..ce856f35 100644
--- a/Makefile
+++ b/Makefile
@@ -2,7 +2,7 @@ UNAME := $(shell uname)
 PWD = $(shell pwd)
 
 # Set the play cpp sdk version
-PLAYCPPSDK=v0.0.23-alpha
+PLAYCPPSDK=v0.0.24-alpha
 # Set the play-cpp-sdk cache path
 PLAYCPPSDK_CACHE_DIR=./install/$(PLAYCPPSDK)
 # Set the play-cpp-sdk target path
diff --git a/Source/CronosPlayUnreal/CronosPlayUnreal.Build.cs b/Source/CronosPlayUnreal/CronosPlayUnreal.Build.cs
index 925dee20..6ef85f93 100644
--- a/Source/CronosPlayUnreal/CronosPlayUnreal.Build.cs
+++ b/Source/CronosPlayUnreal/CronosPlayUnreal.Build.cs
@@ -40,5 +40,13 @@ public CronosPlayUnreal(ReadOnlyTargetRules Target) : base(Target) {
                 "AndroidPlugin",
                 System.IO.Path.Combine(PluginPath, "Android.xml"));
         }
+        if (Target.Platform == UnrealTargetPlatform.Mac) {
+            // Add frameworks for macOS
+            PublicFrameworks.AddRange(new string[] {
+                "Security",
+                "CoreFoundation",
+                "SystemConfiguration"
+            });
+        }
     }
 }
diff --git a/Source/CronosPlayUnreal/Private/PlayCppSdkActor.cpp b/Source/CronosPlayUnreal/Private/PlayCppSdkActor.cpp
index 41bc4f03..bdafe122 100644
--- a/Source/CronosPlayUnreal/Private/PlayCppSdkActor.cpp
+++ b/Source/CronosPlayUnreal/Private/PlayCppSdkActor.cpp
@@ -660,9 +660,10 @@ void APlayCppSdkActor::SendEip155Transaction(
             ::std::array<::std::uint8_t, 20> dstaddress;
             for (int i = 0; i < address.Num(); i++) {
                 dstaddress[i] = address[i];
-            }
+            }          
 
             WalletConnectTxEip155 myinfo;
+            myinfo.from= TCHAR_TO_UTF8(*info.from);
             myinfo.to = TCHAR_TO_UTF8(*info.to);
             myinfo.common.gas_limit = TCHAR_TO_UTF8(*info.gas);
             myinfo.common.gas_price = TCHAR_TO_UTF8(*info.gas_price);
diff --git a/Source/CronosPlayUnreal/Public/PlayCppSdkActor.h b/Source/CronosPlayUnreal/Public/PlayCppSdkActor.h
index 1438cedd..0c881ef0 100644
--- a/Source/CronosPlayUnreal/Public/PlayCppSdkActor.h
+++ b/Source/CronosPlayUnreal/Public/PlayCppSdkActor.h
@@ -183,6 +183,9 @@ struct FWalletConnectTxEip155 {
     GENERATED_USTRUCT_BODY()
     /** hexstring, "0x..." */
     UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PlayCppSdk")
+    FString from;
+    /** hexstring, "0x..." */
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PlayCppSdk")
     FString to;
     /** gas limit in decimal string */
     UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PlayCppSdk")
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/android.cc b/Source/ThirdParty/PlayCppSdkLibrary/Include/android.cc
index 673adae7..c44ffbd3 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/android.cc
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/android.cc
@@ -12,77 +12,76 @@ namespace org {
 namespace defi_wallet_core {
 
 int secureStorageSetJavaEnv(JNIEnv *userenv) {
-    g_env = userenv;
-    return 1;
+  g_env = userenv;
+  return 1;
 }
 
 jclass getSecureStorageClass(JNIEnv *env) {
-    string secureStorageClass = SECURE_STORAGE_CLASS;
-    jclass kotlinClass = env->FindClass(secureStorageClass.c_str());
-    return kotlinClass;
+  string secureStorageClass = SECURE_STORAGE_CLASS;
+  jclass kotlinClass = env->FindClass(secureStorageClass.c_str());
+  return kotlinClass;
 }
 jobject getContext(JNIEnv *env) {
-    jclass activityThreadClass = env->FindClass("android/app/ActivityThread");
-    jmethodID currentActivityThreadMethod =
-        env->GetStaticMethodID(activityThreadClass, "currentActivityThread",
-                               "()Landroid/app/ActivityThread;");
-    jobject activityThread = env->CallStaticObjectMethod(
-        activityThreadClass, currentActivityThreadMethod);
-    jmethodID getApplicationMethod = env->GetMethodID(
-        activityThreadClass, "getApplication", "()Landroid/app/Application;");
-    jobject context =
-        env->CallObjectMethod(activityThread, getApplicationMethod);
-    return context;
+  jclass activityThreadClass = env->FindClass("android/app/ActivityThread");
+  jmethodID currentActivityThreadMethod =
+      env->GetStaticMethodID(activityThreadClass, "currentActivityThread",
+                             "()Landroid/app/ActivityThread;");
+  jobject activityThread = env->CallStaticObjectMethod(
+      activityThreadClass, currentActivityThreadMethod);
+  jmethodID getApplicationMethod = env->GetMethodID(
+      activityThreadClass, "getApplication", "()Landroid/app/Application;");
+  jobject context = env->CallObjectMethod(activityThread, getApplicationMethod);
+  return context;
 }
 int secureStorageWriteBasic(JNIEnv *env, string userkey, string uservalue) {
 
-    jobject context = getContext(env);
-    jclass secureStorageClass = getSecureStorageClass(env);
-    jmethodID functionMethod = env->GetStaticMethodID(
-        secureStorageClass, "writeSecureStorage",
-        "(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;)I");
-    jstring key = env->NewStringUTF(userkey.c_str());
-    jstring value = env->NewStringUTF(uservalue.c_str());
-    jint ret = env->CallStaticIntMethod(secureStorageClass, functionMethod,
-                                        context, key, value);
+  jobject context = getContext(env);
+  jclass secureStorageClass = getSecureStorageClass(env);
+  jmethodID functionMethod = env->GetStaticMethodID(
+      secureStorageClass, "writeSecureStorage",
+      "(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;)I");
+  jstring key = env->NewStringUTF(userkey.c_str());
+  jstring value = env->NewStringUTF(uservalue.c_str());
+  jint ret = env->CallStaticIntMethod(secureStorageClass, functionMethod,
+                                      context, key, value);
 
-    return (int)ret;
+  return (int)ret;
 }
 
 string secureStorageReadBasic(JNIEnv *env, string userkey) {
-    jobject context = getContext(env);
-    jclass secureStorageClass = getSecureStorageClass(env);
-    jmethodID functionMethod = env->GetStaticMethodID(
-        secureStorageClass, "readSecureStorage",
-        "(Landroid/content/Context;Ljava/lang/String;)Ljava/lang/String;");
-    jstring userkeyarg = env->NewStringUTF(userkey.c_str());
-    jobject ret = env->CallStaticObjectMethod(
-        secureStorageClass, functionMethod, context, userkeyarg);
-    string retstring = string(env->GetStringUTFChars((jstring)ret, 0));
+  jobject context = getContext(env);
+  jclass secureStorageClass = getSecureStorageClass(env);
+  jmethodID functionMethod = env->GetStaticMethodID(
+      secureStorageClass, "readSecureStorage",
+      "(Landroid/content/Context;Ljava/lang/String;)Ljava/lang/String;");
+  jstring userkeyarg = env->NewStringUTF(userkey.c_str());
+  jobject ret = env->CallStaticObjectMethod(secureStorageClass, functionMethod,
+                                            context, userkeyarg);
+  string retstring = string(env->GetStringUTFChars((jstring)ret, 0));
 
-    return retstring;
+  return retstring;
 }
 
 int secureStorageWrite(rust::String userkey, rust::String uservalue) {
-    try {
-        JNIEnv *env = g_env;
-        string userkeystring = userkey.c_str();
-        string uservaluestring = uservalue.c_str();
-        int ret = secureStorageWriteBasic(env, userkeystring, uservaluestring);
-        return ret;
-    } catch (exception &e) {
-        return 0; // fail
-    }
+  try {
+    JNIEnv *env = g_env;
+    string userkeystring = userkey.c_str();
+    string uservaluestring = uservalue.c_str();
+    int ret = secureStorageWriteBasic(env, userkeystring, uservaluestring);
+    return ret;
+  } catch (exception &e) {
+    return 0; // fail
+  }
 }
 
 rust::String secureStorageRead(rust::String userkey) {
-    try {
-        JNIEnv *env = g_env;
-        string ret = secureStorageReadBasic(env, userkey.c_str());
-        return rust::String(ret.c_str());
-    } catch (exception &e) {
-        return rust::String(""); // fail
-    }
+  try {
+    JNIEnv *env = g_env;
+    string ret = secureStorageReadBasic(env, userkey.c_str());
+    return rust::String(ret.c_str());
+  } catch (exception &e) {
+    return rust::String(""); // fail
+  }
 }
 
 } // namespace defi_wallet_core
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.cc b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.cc
index f96b90f7..c8e81999 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.cc
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.cc
@@ -20,575 +20,621 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
 class Opaque;
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_SLICE
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+template <typename T>
+void Slice<T>::swap(Slice &rhs) noexcept {
+  std::swap(*this, rhs);
 }
 #endif // CXXBRIDGE1_RUST_SLICE
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -598,21 +644,21 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_ERROR
 #define CXXBRIDGE1_RUST_ERROR
 class Error final : public std::exception {
-  public:
-    Error(const Error &);
-    Error(Error &&) noexcept;
-    ~Error() noexcept override;
+public:
+  Error(const Error &);
+  Error(Error &&) noexcept;
+  ~Error() noexcept override;
 
-    Error &operator=(const Error &) &;
-    Error &operator=(Error &&) &noexcept;
+  Error &operator=(const Error &) &;
+  Error &operator=(Error &&) &noexcept;
 
-    const char *what() const noexcept override;
+  const char *what() const noexcept override;
 
-  private:
-    Error() noexcept = default;
-    friend impl<Error>;
-    const char *msg;
-    std::size_t len;
+private:
+  Error() noexcept = default;
+  friend impl<Error>;
+  const char *msg;
+  std::size_t len;
 };
 #endif // CXXBRIDGE1_RUST_ERROR
 
@@ -631,57 +677,69 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_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>
+struct make_void {
+  using type = void;
+};
 
-template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
 
 template <typename Void, template <typename...> class, typename...>
 struct detect : std::false_type {};
@@ -691,7 +749,8 @@ 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>
+using detect_IsRelocatable = typename T::IsRelocatable;
 
 template <typename T>
 struct get_IsRelocatable
@@ -710,628 +769,456 @@ struct IsRelocatable
 
 namespace repr {
 struct PtrLen final {
-    void *ptr;
-    ::std::size_t len;
+  void *ptr;
+  ::std::size_t len;
 };
 } // namespace repr
 
 namespace detail {
-template <typename T, typename = void *> struct operator_new {
-    void *operator()(::std::size_t sz) { return ::operator new(sz); }
+template <typename T, typename = void *>
+struct operator_new {
+  void *operator()(::std::size_t sz) { return ::operator new(sz); }
 };
 
 template <typename T>
 struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
-    void *operator()(::std::size_t sz) { return T::operator new(sz); }
+  void *operator()(::std::size_t sz) { return T::operator new(sz); }
 };
 } // namespace detail
 
-template <typename T> union ManuallyDrop {
-    T value;
-    ManuallyDrop(T &&value) : value(::std::move(value)) {}
-    ~ManuallyDrop() {}
+template <typename T>
+union ManuallyDrop {
+  T value;
+  ManuallyDrop(T &&value) : value(::std::move(value)) {}
+  ~ManuallyDrop() {}
 };
 
-template <typename T> union MaybeUninit {
-    T value;
-    void *operator new(::std::size_t sz) {
-        return detail::operator_new<T>{}(sz);
-    }
-    MaybeUninit() {}
-    ~MaybeUninit() {}
+template <typename T>
+union MaybeUninit {
+  T value;
+  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
+  MaybeUninit() {}
+  ~MaybeUninit() {}
 };
 
 namespace {
-template <> class impl<Error> final {
-  public:
-    static Error error(repr::PtrLen repr) noexcept {
-        Error error;
-        error.msg = static_cast<char const *>(repr.ptr);
-        error.len = repr.len;
-        return error;
-    }
+template <>
+class impl<Error> final {
+public:
+  static Error error(repr::PtrLen repr) noexcept {
+    Error error;
+    error.msg = static_cast<char const *>(repr.ptr);
+    error.len = repr.len;
+    return error;
+  }
 };
 } // namespace
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct Erc20;
-struct Erc721;
-struct Erc1155;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    struct Erc20;
+    struct Erc721;
+    struct Erc1155;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc20
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc20
 struct Erc20 final {
-    ::rust::String contract_address;
-    ::rust::String web3api_url;
-    bool inner_legacy;
-    ::std::uint64_t inner_polling_interval_ms;
-    ::std::uint64_t chain_id;
-
-    /// Returns the decimal amount of tokens owned by `account_address`.
-    /// # Examples
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338)
-    ///  .legacy();
-    /// U256 = erc20.balance_of("0xf0307093f23311FE6776a7742dB619EB3df62969");
-    /// cout << balance.to_string() << endl;
-    /// ```
-    ::org::defi_wallet_core::U256
-    balance_of(::rust::String account_address) const;
-
-    /// Returns the name of the token
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// String name = erc20.name();
-    /// assert(name == "USDC");
-    /// ```
-    ::rust::String name() const;
-
-    /// Returns the symbol of the token
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// String symbol = erc20.symbol();
-    /// assert(symbol == "USDC");
-    /// ```
-    ::rust::String symbol() const;
-
-    /// Returns the number of decimals the token uses
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338)
-    ///  .legacy();
-    /// uint8_t decimals = erc20.decimals();
-    /// assert(decimals == 6);
-    /// ```
-    ::std::uint8_t decimals() const;
-
-    /// Makes a legacy transaction instead of an EIP-1559 one
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// erc20 = erc20.legacy();
-    /// ```
-    ::org::defi_wallet_core::Erc20 legacy() noexcept;
-
-    /// Sets the default polling interval for event filters and pending
-    /// transactions
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// erc20 = erc20.interval(3000);
-    /// ```
-    ::org::defi_wallet_core::Erc20
-    interval(::std::uint64_t polling_interval_ms) noexcept;
-
-    /// Moves `amount` tokens from the caller’s account to `to_address`.
-    /// # Transfer 100 tokens (devnet)
-    /// ```
-    /// String mycronosrpc = getEnv("MYCRONOSRPC");
-    /// char hdpath[100];
-    /// int cointype = 60;
-    /// int chainid = 777;
-    /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
-    ///
-    /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
-    /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
-    /// String signer1_address = signer1_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
-    ///
-    /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
-    /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
-    /// String signer2_address = signer2_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
-    ///
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.transfer(signer2_address, "100", *privatekey);
-    /// ```
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    transfer(::rust::String to_address, ::rust::String amount,
-             ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Moves `amount` tokens from `from_address` to `to_address` using the
-    /// allowance mechanism. # Transfer from signer1 to validator1 using the
-    /// allowance mechanism (devnet)
-    /// ```
-    /// String mycronosrpc = getEnv("MYCRONOSRPC");
-    /// char hdpath[100];
-    /// int cointype = 60;
-    /// int chainid = 777;
-    /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
-    ///
-    /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
-    /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
-    /// String signer1_address = signer1_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
-    ///
-    /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
-    /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
-    /// String signer2_address = signer2_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
-    ///
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.transfer_from(signer1_address, validator1_address, "100",
-    ///                 *signer2_privatekey);
-    /// ```
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    transfer_from(::rust::String from_address, ::rust::String to_address,
-                  ::rust::String amount,
-                  ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Allows `approved_address` to withdraw from your account multiple times,
-    /// up to the `amount` amount.
-    /// ## approves 1000 allowance (devnet)
-    /// ```
-    /// String mycronosrpc = getEnv("MYCRONOSRPC");
-    /// char hdpath[100];
-    /// int cointype = 60;
-    /// int chainid = 777;
-    /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
-    ///
-    /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
-    /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
-    /// String signer1_address = signer1_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
-    ///
-    /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
-    /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
-    /// String signer2_address = signer2_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
-    ///
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.interval(3000).approve(signer2_address, "1000",
-    /// *signer1_privatekey);
-    /// ```
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    approve(::rust::String approved_address, ::rust::String amount,
-            ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Returns the amount which `spender` is still allowed to withdraw from
-    /// `owner`.
-    /// ```
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.allowance(owner, spender);
-    /// ```
-    ::rust::String allowance(::rust::String owner,
-                             ::rust::String spender) const;
-
-    /// Returns the amount of tokens in existence.
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///                         "https://evm-dev-t3.cronos.org", 338)
-    ///                 .legacy();
-    /// U256 total_supply = erc20.total_supply();
-    /// ```
-    ::org::defi_wallet_core::U256 total_supply() const;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String contract_address;
+  ::rust::String web3api_url;
+  bool inner_legacy;
+  ::std::uint64_t inner_polling_interval_ms;
+  ::std::uint64_t chain_id;
+
+  /// Returns the decimal amount of tokens owned by `account_address`.
+  /// # Examples
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338)
+  ///  .legacy();
+  /// U256 = erc20.balance_of("0xf0307093f23311FE6776a7742dB619EB3df62969");
+  /// cout << balance.to_string() << endl;
+  /// ```
+  ::org::defi_wallet_core::U256 balance_of(::rust::String account_address) const;
+
+  /// Returns the name of the token
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// String name = erc20.name();
+  /// assert(name == "USDC");
+  /// ```
+  ::rust::String name() const;
+
+  /// Returns the symbol of the token
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// String symbol = erc20.symbol();
+  /// assert(symbol == "USDC");
+  /// ```
+  ::rust::String symbol() const;
+
+  /// Returns the number of decimals the token uses
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338)
+  ///  .legacy();
+  /// uint8_t decimals = erc20.decimals();
+  /// assert(decimals == 6);
+  /// ```
+  ::std::uint8_t decimals() const;
+
+  /// Makes a legacy transaction instead of an EIP-1559 one
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// erc20 = erc20.legacy();
+  /// ```
+  ::org::defi_wallet_core::Erc20 legacy() noexcept;
+
+  /// Sets the default polling interval for event filters and pending transactions
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// erc20 = erc20.interval(3000);
+  /// ```
+  ::org::defi_wallet_core::Erc20 interval(::std::uint64_t polling_interval_ms) noexcept;
+
+  /// Moves `amount` tokens from the caller’s account to `to_address`.
+  /// # Transfer 100 tokens (devnet)
+  /// ```
+  /// String mycronosrpc = getEnv("MYCRONOSRPC");
+  /// char hdpath[100];
+  /// int cointype = 60;
+  /// int chainid = 777;
+  /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
+  ///
+  /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
+  /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
+  /// String signer1_address = signer1_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
+  ///
+  /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
+  /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
+  /// String signer2_address = signer2_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
+  ///
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.transfer(signer2_address, "100", *privatekey);
+  /// ```
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw transfer(::rust::String to_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Moves `amount` tokens from `from_address` to `to_address` using the allowance mechanism.
+  /// # Transfer from signer1 to validator1 using the allowance mechanism (devnet)
+  /// ```
+  /// String mycronosrpc = getEnv("MYCRONOSRPC");
+  /// char hdpath[100];
+  /// int cointype = 60;
+  /// int chainid = 777;
+  /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
+  ///
+  /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
+  /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
+  /// String signer1_address = signer1_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
+  ///
+  /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
+  /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
+  /// String signer2_address = signer2_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
+  ///
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.transfer_from(signer1_address, validator1_address, "100",
+  ///                 *signer2_privatekey);
+  /// ```
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Allows `approved_address` to withdraw from your account multiple times, up to the
+  /// `amount` amount.
+  /// ## approves 1000 allowance (devnet)
+  /// ```
+  /// String mycronosrpc = getEnv("MYCRONOSRPC");
+  /// char hdpath[100];
+  /// int cointype = 60;
+  /// int chainid = 777;
+  /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
+  ///
+  /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
+  /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
+  /// String signer1_address = signer1_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
+  ///
+  /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
+  /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
+  /// String signer2_address = signer2_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
+  ///
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.interval(3000).approve(signer2_address, "1000", *signer1_privatekey);
+  /// ```
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw approve(::rust::String approved_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Returns the amount which `spender` is still allowed to withdraw from `owner`.
+  /// ```
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.allowance(owner, spender);
+  /// ```
+  ::rust::String allowance(::rust::String owner, ::rust::String spender) const;
+
+  /// Returns the amount of tokens in existence.
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///                         "https://evm-dev-t3.cronos.org", 338)
+  ///                 .legacy();
+  /// U256 total_supply = erc20.total_supply();
+  /// ```
+  ::org::defi_wallet_core::U256 total_supply() const;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc20
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc721
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc721
 struct Erc721 final {
-    ::rust::String contract_address;
-    ::rust::String web3api_url;
-    bool inner_legacy;
-    ::std::uint64_t inner_polling_interval_ms;
-    ::std::uint64_t chain_id;
-
-    /// Returns the number of tokens in owner's `account_address`.
-    ///
-    ::org::defi_wallet_core::U256
-    balance_of(::rust::String account_address) const;
-
-    /// Returns the owner of the `token_id` token.
-    ///
-    ::rust::String owner_of(::rust::String token_id) const;
-
-    /// Get the descriptive name for a collection of NFTs in this contract
-    ///
-    ::rust::String name() const;
-
-    /// Get the abbreviated name for NFTs in this contract
-    ///
-    ::rust::String symbol() const;
-
-    /// Get the distinct Uniform Resource Identifier (URI) for a given asset
-    ///
-    ::rust::String token_uri(::rust::String token_id) const;
-
-    /// Makes a legacy transaction instead of an EIP-1559 one
-    ///
-    ::org::defi_wallet_core::Erc721 legacy() noexcept;
-
-    /// Sets the default polling interval for event filters and pending
-    /// transactions
-    ///
-    ::org::defi_wallet_core::Erc721
-    interval(::std::uint64_t polling_interval_ms) noexcept;
-
-    /// Transfers `token_id` token from `from_address` to `to_address`.
-    ///
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    transfer_from(::rust::String from_address, ::rust::String to_address,
-                  ::rust::String token_id,
-                  ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Safely transfers `token_id` token from `from_address` to `to_address`.
-    ///
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::String token_id,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Safely transfers `token_id` token from `from_address` to `to_address`
-    /// with `additional_data`.
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    safe_transfer_from_with_data(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::String token_id, ::rust::Vec<::std::uint8_t> additional_data,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Gives permission to `approved_address` to transfer `token_id` token to
-    /// another account. The approval is cleared when the token is transferred.
-    /// Only a single account can be approved at a time, so approving the zero
-    /// address clears previous approvals.
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    approve(::rust::String approved_address, ::rust::String token_id,
-            ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Enable or disable approval for a third party `approved_address` to
-    /// manage all of sender's assets
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(
-        ::rust::String approved_address, bool approved,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Get the approved address for a single NFT by `token_id`
-    ///
-    ::rust::String get_approved(::rust::String token_id) const;
-
-    /// Query if an address is an authorized `approved_address` for `owner`
-    ///
-    bool is_approved_for_all(::rust::String owner,
-                             ::rust::String approved_address) const;
-
-    /// Returns the total amount of tokens stored by the contract.
-    ///
-    /// From IERC721Enumerable, an optional extension of the standard ERC721
-    ::org::defi_wallet_core::U256 total_supply() const;
-
-    /// Returns a token ID at a given index of all the tokens stored by the
-    /// contract. Use along with totalSupply to enumerate all tokens.
-    ///
-    /// From IERC721Enumerable, an optional extension of the standard ERC721
-    ::rust::String token_by_index(::rust::String index) const;
-
-    /// Returns a token ID owned by owner at a given index of its token list.
-    /// Use along with balanceOf to enumerate all of owner's tokens.
-    ///
-    /// From IERC721Enumerable, an optional extension of the standard ERC721
-    ::rust::String token_of_owner_by_index(::rust::String owner,
-                                           ::rust::String index) const;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String contract_address;
+  ::rust::String web3api_url;
+  bool inner_legacy;
+  ::std::uint64_t inner_polling_interval_ms;
+  ::std::uint64_t chain_id;
+
+  /// Returns the number of tokens in owner's `account_address`.
+  ///
+  ::org::defi_wallet_core::U256 balance_of(::rust::String account_address) const;
+
+  /// Returns the owner of the `token_id` token.
+  ///
+  ::rust::String owner_of(::rust::String token_id) const;
+
+  /// Get the descriptive name for a collection of NFTs in this contract
+  ///
+  ::rust::String name() const;
+
+  /// Get the abbreviated name for NFTs in this contract
+  ///
+  ::rust::String symbol() const;
+
+  /// Get the distinct Uniform Resource Identifier (URI) for a given asset
+  ///
+  ::rust::String token_uri(::rust::String token_id) const;
+
+  /// Makes a legacy transaction instead of an EIP-1559 one
+  ///
+  ::org::defi_wallet_core::Erc721 legacy() noexcept;
+
+  /// Sets the default polling interval for event filters and pending transactions
+  ///
+  ::org::defi_wallet_core::Erc721 interval(::std::uint64_t polling_interval_ms) noexcept;
+
+  /// Transfers `token_id` token from `from_address` to `to_address`.
+  ///
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Safely transfers `token_id` token from `from_address` to `to_address`.
+  ///
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Safely transfers `token_id` token from `from_address` to `to_address` with
+  /// `additional_data`.
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from_with_data(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Gives permission to `approved_address` to transfer `token_id` token to another account.
+  /// The approval is cleared when the token is transferred. Only a single account can be
+  /// approved at a time, so approving the zero address clears previous approvals.
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw approve(::rust::String approved_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Enable or disable approval for a third party `approved_address` to manage all of
+  /// sender's assets
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(::rust::String approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Get the approved address for a single NFT by `token_id`
+  ///
+  ::rust::String get_approved(::rust::String token_id) const;
+
+  /// Query if an address is an authorized `approved_address` for `owner`
+  ///
+  bool is_approved_for_all(::rust::String owner, ::rust::String approved_address) const;
+
+  /// Returns the total amount of tokens stored by the contract.
+  ///
+  /// From IERC721Enumerable, an optional extension of the standard ERC721
+  ::org::defi_wallet_core::U256 total_supply() const;
+
+  /// Returns a token ID at a given index of all the tokens stored by the contract. Use along
+  /// with totalSupply to enumerate all tokens.
+  ///
+  /// From IERC721Enumerable, an optional extension of the standard ERC721
+  ::rust::String token_by_index(::rust::String index) const;
+
+  /// Returns a token ID owned by owner at a given index of its token list. Use along with
+  /// balanceOf to enumerate all of owner's tokens.
+  ///
+  /// From IERC721Enumerable, an optional extension of the standard ERC721
+  ::rust::String token_of_owner_by_index(::rust::String owner, ::rust::String index) const;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc721
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc1155
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc1155
 struct Erc1155 final {
-    ::rust::String contract_address;
-    ::rust::String web3api_url;
-    bool inner_legacy;
-    ::std::uint64_t inner_polling_interval_ms;
-    ::std::uint64_t chain_id;
-
-    /// Returns the amount of tokens of `token_id` owned by `account_address`.
-    ///
-    ::org::defi_wallet_core::U256 balance_of(::rust::String account_address,
-                                             ::rust::String token_id) const;
-
-    /// Batched version of balance_of.
-    /// Get the balance of multiple account/token pairs
-    ::rust::Vec<::rust::String>
-    balance_of_batch(::rust::Vec<::rust::String> account_addresses,
-                     ::rust::Vec<::rust::String> token_ids) const;
-
-    /// Get distinct Uniform Resource Identifier (URI) for a given token
-    ///
-    ::rust::String uri(::rust::String token_id) const;
-
-    /// Makes a legacy transaction instead of an EIP-1559 one
-    ///
-    ::org::defi_wallet_core::Erc1155 legacy() noexcept;
-
-    /// Sets the default polling interval for event filters and pending
-    /// transactions
-    ///
-    ::org::defi_wallet_core::Erc1155
-    interval(::std::uint64_t polling_interval_ms) noexcept;
-
-    /// Transfers `amount` tokens of `token_id` from `from_address` to
-    /// `to_address` with `additional_data`.
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::String token_id, ::rust::String amount,
-        ::rust::Vec<::std::uint8_t> additional_data,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Batched version of safeTransferFrom.
-    ///
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    safe_batch_transfer_from(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::Vec<::rust::String> token_ids,
-        ::rust::Vec<::rust::String> amounts,
-        ::rust::Vec<::std::uint8_t> additional_data,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Enable or disable approval for a third party `approved_address` to
-    /// manage all of sender's assets
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(
-        ::rust::String approved_address, bool approved,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Query if an address is an authorized `approved_address` for `owner`
-    ///
-    bool is_approved_for_all(::rust::String owner,
-                             ::rust::String approved_address) const;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String contract_address;
+  ::rust::String web3api_url;
+  bool inner_legacy;
+  ::std::uint64_t inner_polling_interval_ms;
+  ::std::uint64_t chain_id;
+
+  /// Returns the amount of tokens of `token_id` owned by `account_address`.
+  ///
+  ::org::defi_wallet_core::U256 balance_of(::rust::String account_address, ::rust::String token_id) const;
+
+  /// Batched version of balance_of.
+  /// Get the balance of multiple account/token pairs
+  ::rust::Vec<::rust::String> balance_of_batch(::rust::Vec<::rust::String> account_addresses, ::rust::Vec<::rust::String> token_ids) const;
+
+  /// Get distinct Uniform Resource Identifier (URI) for a given token
+  ///
+  ::rust::String uri(::rust::String token_id) const;
+
+  /// Makes a legacy transaction instead of an EIP-1559 one
+  ///
+  ::org::defi_wallet_core::Erc1155 legacy() noexcept;
+
+  /// Sets the default polling interval for event filters and pending transactions
+  ///
+  ::org::defi_wallet_core::Erc1155 interval(::std::uint64_t polling_interval_ms) noexcept;
+
+  /// Transfers `amount` tokens of `token_id` from `from_address` to `to_address` with
+  /// `additional_data`.
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::rust::String amount, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Batched version of safeTransferFrom.
+  ///
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_batch_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::Vec<::rust::String> token_ids, ::rust::Vec<::rust::String> amounts, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Enable or disable approval for a third party `approved_address` to manage all of
+  /// sender's assets
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(::rust::String approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Query if an address is an authorized `approved_address` for `owner`
+  ///
+  bool is_approved_for_all(::rust::String owner, ::rust::String approved_address) const;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc1155
 } // namespace defi_wallet_core
 } // namespace org
 
 static_assert(
-    ::rust::IsRelocatable<
-        ::org::defi_wallet_core::CronosTransactionReceiptRaw>::value,
-    "type org::defi_wallet_core::CronosTransactionReceiptRaw should be "
-    "trivially move constructible and trivially destructible in C++ to be used "
-    "as a return value of `transfer`, `transfer_from`, `approve` in Rust");
-static_assert(::rust::IsRelocatable<::org::defi_wallet_core::U256>::value,
-              "type org::defi_wallet_core::U256 should be trivially move "
-              "constructible and trivially destructible in C++ to be used as a "
-              "return value of `balance_of`, `total_supply` in Rust");
+    ::rust::IsRelocatable<::org::defi_wallet_core::CronosTransactionReceiptRaw>::value,
+    "type org::defi_wallet_core::CronosTransactionReceiptRaw should be trivially move constructible and trivially destructible in C++ to be used as a return value of `transfer`, `transfer_from`, `approve` in Rust");
+static_assert(
+    ::rust::IsRelocatable<::org::defi_wallet_core::U256>::value,
+    "type org::defi_wallet_core::U256 should be trivially move constructible and trivially destructible in C++ to be used as a return value of `balance_of`, `total_supply` in Rust");
 
 namespace org {
 namespace defi_wallet_core {
 extern "C" {
-void org$defi_wallet_core$cxxbridge1$new_erc20(
-    ::rust::String *address, ::rust::String *web3api_url,
-    ::std::uint64_t chian_id, ::org::defi_wallet_core::Erc20 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$balance_of(
-    ::org::defi_wallet_core::Erc20 const &self, ::rust::String *account_address,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$name(
-    ::org::defi_wallet_core::Erc20 const &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$symbol(
-    ::org::defi_wallet_core::Erc20 const &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$decimals(
-    ::org::defi_wallet_core::Erc20 const &self,
-    ::std::uint8_t *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Erc20$legacy(
-    ::org::defi_wallet_core::Erc20 &self,
-    ::org::defi_wallet_core::Erc20 *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Erc20$interval(
-    ::org::defi_wallet_core::Erc20 &self, ::std::uint64_t polling_interval_ms,
-    ::org::defi_wallet_core::Erc20 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$transfer(
-    ::org::defi_wallet_core::Erc20 const &self, ::rust::String *to_address,
-    ::rust::String *amount,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$transfer_from(
-    ::org::defi_wallet_core::Erc20 const &self, ::rust::String *from_address,
-    ::rust::String *to_address, ::rust::String *amount,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$approve(
-    ::org::defi_wallet_core::Erc20 const &self,
-    ::rust::String *approved_address, ::rust::String *amount,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$allowance(
-    ::org::defi_wallet_core::Erc20 const &self, ::rust::String *owner,
-    ::rust::String *spender, ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$total_supply(
-    ::org::defi_wallet_core::Erc20 const &self,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$new_erc721(
-    ::rust::String *address, ::rust::String *web3api_url,
-    ::std::uint64_t chian_id,
-    ::org::defi_wallet_core::Erc721 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$balance_of(
-    ::org::defi_wallet_core::Erc721 const &self,
-    ::rust::String *account_address,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$owner_of(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *token_id,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$name(
-    ::org::defi_wallet_core::Erc721 const &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$symbol(
-    ::org::defi_wallet_core::Erc721 const &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$token_uri(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *token_id,
-    ::rust::String *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Erc721$legacy(
-    ::org::defi_wallet_core::Erc721 &self,
-    ::org::defi_wallet_core::Erc721 *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Erc721$interval(
-    ::org::defi_wallet_core::Erc721 &self, ::std::uint64_t polling_interval_ms,
-    ::org::defi_wallet_core::Erc721 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$transfer_from(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *from_address,
-    ::rust::String *to_address, ::rust::String *token_id,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *from_address,
-    ::rust::String *to_address, ::rust::String *token_id,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from_with_data(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *from_address,
-    ::rust::String *to_address, ::rust::String *token_id,
-    ::rust::Vec<::std::uint8_t> *additional_data,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$approve(
-    ::org::defi_wallet_core::Erc721 const &self,
-    ::rust::String *approved_address, ::rust::String *token_id,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$Erc721$set_approval_for_all(
-    ::org::defi_wallet_core::Erc721 const &self,
-    ::rust::String *approved_address, bool approved,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$get_approved(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *token_id,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$is_approved_for_all(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *owner,
-    ::rust::String *approved_address, bool *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$total_supply(
-    ::org::defi_wallet_core::Erc721 const &self,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$token_by_index(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *index,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$Erc721$token_of_owner_by_index(
-    ::org::defi_wallet_core::Erc721 const &self, ::rust::String *owner,
-    ::rust::String *index, ::rust::String *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$new_erc1155(
-    ::rust::String *address, ::rust::String *web3api_url,
-    ::std::uint64_t chian_id,
-    ::org::defi_wallet_core::Erc1155 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$balance_of(
-    ::org::defi_wallet_core::Erc1155 const &self,
-    ::rust::String *account_address, ::rust::String *token_id,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$balance_of_batch(
-    ::org::defi_wallet_core::Erc1155 const &self,
-    ::rust::Vec<::rust::String> *account_addresses,
-    ::rust::Vec<::rust::String> *token_ids,
-    ::rust::Vec<::rust::String> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$uri(
-    ::org::defi_wallet_core::Erc1155 const &self, ::rust::String *token_id,
-    ::rust::String *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Erc1155$legacy(
-    ::org::defi_wallet_core::Erc1155 &self,
-    ::org::defi_wallet_core::Erc1155 *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Erc1155$interval(
-    ::org::defi_wallet_core::Erc1155 &self, ::std::uint64_t polling_interval_ms,
-    ::org::defi_wallet_core::Erc1155 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$safe_transfer_from(
-    ::org::defi_wallet_core::Erc1155 const &self, ::rust::String *from_address,
-    ::rust::String *to_address, ::rust::String *token_id,
-    ::rust::String *amount, ::rust::Vec<::std::uint8_t> *additional_data,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$Erc1155$safe_batch_transfer_from(
-    ::org::defi_wallet_core::Erc1155 const &self, ::rust::String *from_address,
-    ::rust::String *to_address, ::rust::Vec<::rust::String> *token_ids,
-    ::rust::Vec<::rust::String> *amounts,
-    ::rust::Vec<::std::uint8_t> *additional_data,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$Erc1155$set_approval_for_all(
-    ::org::defi_wallet_core::Erc1155 const &self,
-    ::rust::String *approved_address, bool approved,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$Erc1155$is_approved_for_all(
-    ::org::defi_wallet_core::Erc1155 const &self, ::rust::String *owner,
-    ::rust::String *approved_address, bool *return$) noexcept;
+void org$defi_wallet_core$cxxbridge1$new_erc20(::rust::String *address, ::rust::String *web3api_url, ::std::uint64_t chian_id, ::org::defi_wallet_core::Erc20 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$balance_of(::org::defi_wallet_core::Erc20 const &self, ::rust::String *account_address, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$name(::org::defi_wallet_core::Erc20 const &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$symbol(::org::defi_wallet_core::Erc20 const &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$decimals(::org::defi_wallet_core::Erc20 const &self, ::std::uint8_t *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Erc20$legacy(::org::defi_wallet_core::Erc20 &self, ::org::defi_wallet_core::Erc20 *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Erc20$interval(::org::defi_wallet_core::Erc20 &self, ::std::uint64_t polling_interval_ms, ::org::defi_wallet_core::Erc20 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$transfer(::org::defi_wallet_core::Erc20 const &self, ::rust::String *to_address, ::rust::String *amount, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$transfer_from(::org::defi_wallet_core::Erc20 const &self, ::rust::String *from_address, ::rust::String *to_address, ::rust::String *amount, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$approve(::org::defi_wallet_core::Erc20 const &self, ::rust::String *approved_address, ::rust::String *amount, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$allowance(::org::defi_wallet_core::Erc20 const &self, ::rust::String *owner, ::rust::String *spender, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc20$total_supply(::org::defi_wallet_core::Erc20 const &self, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$new_erc721(::rust::String *address, ::rust::String *web3api_url, ::std::uint64_t chian_id, ::org::defi_wallet_core::Erc721 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$balance_of(::org::defi_wallet_core::Erc721 const &self, ::rust::String *account_address, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$owner_of(::org::defi_wallet_core::Erc721 const &self, ::rust::String *token_id, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$name(::org::defi_wallet_core::Erc721 const &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$symbol(::org::defi_wallet_core::Erc721 const &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$token_uri(::org::defi_wallet_core::Erc721 const &self, ::rust::String *token_id, ::rust::String *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Erc721$legacy(::org::defi_wallet_core::Erc721 &self, ::org::defi_wallet_core::Erc721 *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Erc721$interval(::org::defi_wallet_core::Erc721 &self, ::std::uint64_t polling_interval_ms, ::org::defi_wallet_core::Erc721 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$transfer_from(::org::defi_wallet_core::Erc721 const &self, ::rust::String *from_address, ::rust::String *to_address, ::rust::String *token_id, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from(::org::defi_wallet_core::Erc721 const &self, ::rust::String *from_address, ::rust::String *to_address, ::rust::String *token_id, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from_with_data(::org::defi_wallet_core::Erc721 const &self, ::rust::String *from_address, ::rust::String *to_address, ::rust::String *token_id, ::rust::Vec<::std::uint8_t> *additional_data, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$approve(::org::defi_wallet_core::Erc721 const &self, ::rust::String *approved_address, ::rust::String *token_id, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$set_approval_for_all(::org::defi_wallet_core::Erc721 const &self, ::rust::String *approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$get_approved(::org::defi_wallet_core::Erc721 const &self, ::rust::String *token_id, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$is_approved_for_all(::org::defi_wallet_core::Erc721 const &self, ::rust::String *owner, ::rust::String *approved_address, bool *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$total_supply(::org::defi_wallet_core::Erc721 const &self, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$token_by_index(::org::defi_wallet_core::Erc721 const &self, ::rust::String *index, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc721$token_of_owner_by_index(::org::defi_wallet_core::Erc721 const &self, ::rust::String *owner, ::rust::String *index, ::rust::String *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$new_erc1155(::rust::String *address, ::rust::String *web3api_url, ::std::uint64_t chian_id, ::org::defi_wallet_core::Erc1155 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$balance_of(::org::defi_wallet_core::Erc1155 const &self, ::rust::String *account_address, ::rust::String *token_id, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$balance_of_batch(::org::defi_wallet_core::Erc1155 const &self, ::rust::Vec<::rust::String> *account_addresses, ::rust::Vec<::rust::String> *token_ids, ::rust::Vec<::rust::String> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$uri(::org::defi_wallet_core::Erc1155 const &self, ::rust::String *token_id, ::rust::String *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Erc1155$legacy(::org::defi_wallet_core::Erc1155 &self, ::org::defi_wallet_core::Erc1155 *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Erc1155$interval(::org::defi_wallet_core::Erc1155 &self, ::std::uint64_t polling_interval_ms, ::org::defi_wallet_core::Erc1155 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$safe_transfer_from(::org::defi_wallet_core::Erc1155 const &self, ::rust::String *from_address, ::rust::String *to_address, ::rust::String *token_id, ::rust::String *amount, ::rust::Vec<::std::uint8_t> *additional_data, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$safe_batch_transfer_from(::org::defi_wallet_core::Erc1155 const &self, ::rust::String *from_address, ::rust::String *to_address, ::rust::Vec<::rust::String> *token_ids, ::rust::Vec<::rust::String> *amounts, ::rust::Vec<::std::uint8_t> *additional_data, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$set_approval_for_all(::org::defi_wallet_core::Erc1155 const &self, ::rust::String *approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Erc1155$is_approved_for_all(::org::defi_wallet_core::Erc1155 const &self, ::rust::String *owner, ::rust::String *approved_address, bool *return$) noexcept;
 } // extern "C"
 
 /// Construct an Erc20 struct
@@ -1339,489 +1226,348 @@ org$defi_wallet_core$cxxbridge1$Erc1155$is_approved_for_all(
 /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
 ///    "https://evm-dev-t3.cronos.org", 338);
 /// ```
-::org::defi_wallet_core::Erc20 new_erc20(::rust::String address,
-                                         ::rust::String web3api_url,
-                                         ::std::uint64_t chian_id) noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc20> return$;
-    org$defi_wallet_core$cxxbridge1$new_erc20(&address, &web3api_url, chian_id,
-                                              &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::U256
-Erc20::balance_of(::rust::String account_address) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$balance_of(
-            *this, &account_address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::Erc20 new_erc20(::rust::String address, ::rust::String web3api_url, ::std::uint64_t chian_id) noexcept {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc20> return$;
+  org$defi_wallet_core$cxxbridge1$new_erc20(&address, &web3api_url, chian_id, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::U256 Erc20::balance_of(::rust::String account_address) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$balance_of(*this, &account_address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc20::name() const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$name(*this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$name(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc20::symbol() const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$symbol(*this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$symbol(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::std::uint8_t Erc20::decimals() const {
-    ::rust::MaybeUninit<::std::uint8_t> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$decimals(*this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::std::uint8_t> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$decimals(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::org::defi_wallet_core::Erc20 Erc20::legacy() noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc20> return$;
-    org$defi_wallet_core$cxxbridge1$Erc20$legacy(*this, &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::Erc20
-Erc20::interval(::std::uint64_t polling_interval_ms) noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc20> return$;
-    org$defi_wallet_core$cxxbridge1$Erc20$interval(*this, polling_interval_ms,
-                                                   &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc20::transfer(::rust::String to_address, ::rust::String amount,
-                ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$transfer(
-            *this, &to_address, &amount, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw Erc20::transfer_from(
-    ::rust::String from_address, ::rust::String to_address,
-    ::rust::String amount,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$transfer_from(
-            *this, &from_address, &to_address, &amount, private_key,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc20::approve(::rust::String approved_address, ::rust::String amount,
-               ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$approve(
-        *this, &approved_address, &amount, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::String Erc20::allowance(::rust::String owner,
-                                ::rust::String spender) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$allowance(*this, &owner, &spender,
-                                                        &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc20> return$;
+  org$defi_wallet_core$cxxbridge1$Erc20$legacy(*this, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::Erc20 Erc20::interval(::std::uint64_t polling_interval_ms) noexcept {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc20> return$;
+  org$defi_wallet_core$cxxbridge1$Erc20$interval(*this, polling_interval_ms, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc20::transfer(::rust::String to_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$transfer(*this, &to_address, &amount, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc20::transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$transfer_from(*this, &from_address, &to_address, &amount, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc20::approve(::rust::String approved_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$approve(*this, &approved_address, &amount, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String Erc20::allowance(::rust::String owner, ::rust::String spender) const {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$allowance(*this, &owner, &spender, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::org::defi_wallet_core::U256 Erc20::total_supply() const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc20$total_supply(*this,
-                                                           &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc20$total_supply(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// Construct an Erc721 struct
 ///
-::org::defi_wallet_core::Erc721 new_erc721(::rust::String address,
-                                           ::rust::String web3api_url,
-                                           ::std::uint64_t chian_id) noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc721> return$;
-    org$defi_wallet_core$cxxbridge1$new_erc721(&address, &web3api_url, chian_id,
-                                               &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::U256
-Erc721::balance_of(::rust::String account_address) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$balance_of(
-            *this, &account_address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::Erc721 new_erc721(::rust::String address, ::rust::String web3api_url, ::std::uint64_t chian_id) noexcept {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc721> return$;
+  org$defi_wallet_core$cxxbridge1$new_erc721(&address, &web3api_url, chian_id, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::U256 Erc721::balance_of(::rust::String account_address) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$balance_of(*this, &account_address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc721::owner_of(::rust::String token_id) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$owner_of(*this, &token_id,
-                                                        &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$owner_of(*this, &token_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc721::name() const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$name(*this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$name(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc721::symbol() const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$symbol(*this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$symbol(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc721::token_uri(::rust::String token_id) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$token_uri(*this, &token_id,
-                                                         &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$token_uri(*this, &token_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::org::defi_wallet_core::Erc721 Erc721::legacy() noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc721> return$;
-    org$defi_wallet_core$cxxbridge1$Erc721$legacy(*this, &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::Erc721
-Erc721::interval(::std::uint64_t polling_interval_ms) noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc721> return$;
-    org$defi_wallet_core$cxxbridge1$Erc721$interval(*this, polling_interval_ms,
-                                                    &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw Erc721::transfer_from(
-    ::rust::String from_address, ::rust::String to_address,
-    ::rust::String token_id,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$transfer_from(
-            *this, &from_address, &to_address, &token_id, private_key,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw Erc721::safe_transfer_from(
-    ::rust::String from_address, ::rust::String to_address,
-    ::rust::String token_id,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from(
-            *this, &from_address, &to_address, &token_id, private_key,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc721::safe_transfer_from_with_data(
-    ::rust::String from_address, ::rust::String to_address,
-    ::rust::String token_id, ::rust::Vec<::std::uint8_t> additional_data,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> additional_data$(
-        ::std::move(additional_data));
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from_with_data(
-            *this, &from_address, &to_address, &token_id,
-            &additional_data$.value, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc721::approve(::rust::String approved_address, ::rust::String token_id,
-                ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$approve(
-            *this, &approved_address, &token_id, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc721::set_approval_for_all(
-    ::rust::String approved_address, bool approved,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$set_approval_for_all(
-            *this, &approved_address, approved, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc721> return$;
+  org$defi_wallet_core$cxxbridge1$Erc721$legacy(*this, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::Erc721 Erc721::interval(::std::uint64_t polling_interval_ms) noexcept {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc721> return$;
+  org$defi_wallet_core$cxxbridge1$Erc721$interval(*this, polling_interval_ms, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc721::transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$transfer_from(*this, &from_address, &to_address, &token_id, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc721::safe_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from(*this, &from_address, &to_address, &token_id, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc721::safe_transfer_from_with_data(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> additional_data$(::std::move(additional_data));
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$safe_transfer_from_with_data(*this, &from_address, &to_address, &token_id, &additional_data$.value, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc721::approve(::rust::String approved_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$approve(*this, &approved_address, &token_id, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc721::set_approval_for_all(::rust::String approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$set_approval_for_all(*this, &approved_address, approved, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc721::get_approved(::rust::String token_id) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$get_approved(*this, &token_id,
-                                                            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-bool Erc721::is_approved_for_all(::rust::String owner,
-                                 ::rust::String approved_address) const {
-    ::rust::MaybeUninit<bool> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$is_approved_for_all(
-            *this, &owner, &approved_address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$get_approved(*this, &token_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+bool Erc721::is_approved_for_all(::rust::String owner, ::rust::String approved_address) const {
+  ::rust::MaybeUninit<bool> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$is_approved_for_all(*this, &owner, &approved_address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::org::defi_wallet_core::U256 Erc721::total_supply() const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$total_supply(*this,
-                                                            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$total_supply(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc721::token_by_index(::rust::String index) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$token_by_index(*this, &index,
-                                                              &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::String Erc721::token_of_owner_by_index(::rust::String owner,
-                                               ::rust::String index) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc721$token_of_owner_by_index(
-            *this, &owner, &index, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$token_by_index(*this, &index, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String Erc721::token_of_owner_by_index(::rust::String owner, ::rust::String index) const {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc721$token_of_owner_by_index(*this, &owner, &index, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// Construct an Erc1155 struct
 ///
-::org::defi_wallet_core::Erc1155
-new_erc1155(::rust::String address, ::rust::String web3api_url,
-            ::std::uint64_t chian_id) noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc1155> return$;
-    org$defi_wallet_core$cxxbridge1$new_erc1155(&address, &web3api_url,
-                                                chian_id, &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::U256
-Erc1155::balance_of(::rust::String account_address,
-                    ::rust::String token_id) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc1155$balance_of(
-            *this, &account_address, &token_id, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::rust::String>
-Erc1155::balance_of_batch(::rust::Vec<::rust::String> account_addresses,
-                          ::rust::Vec<::rust::String> token_ids) const {
-    ::rust::ManuallyDrop<::rust::Vec<::rust::String>> account_addresses$(
-        ::std::move(account_addresses));
-    ::rust::ManuallyDrop<::rust::Vec<::rust::String>> token_ids$(
-        ::std::move(token_ids));
-    ::rust::MaybeUninit<::rust::Vec<::rust::String>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc1155$balance_of_batch(
-            *this, &account_addresses$.value, &token_ids$.value,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::Erc1155 new_erc1155(::rust::String address, ::rust::String web3api_url, ::std::uint64_t chian_id) noexcept {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc1155> return$;
+  org$defi_wallet_core$cxxbridge1$new_erc1155(&address, &web3api_url, chian_id, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::U256 Erc1155::balance_of(::rust::String account_address, ::rust::String token_id) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$balance_of(*this, &account_address, &token_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::rust::String> Erc1155::balance_of_batch(::rust::Vec<::rust::String> account_addresses, ::rust::Vec<::rust::String> token_ids) const {
+  ::rust::ManuallyDrop<::rust::Vec<::rust::String>> account_addresses$(::std::move(account_addresses));
+  ::rust::ManuallyDrop<::rust::Vec<::rust::String>> token_ids$(::std::move(token_ids));
+  ::rust::MaybeUninit<::rust::Vec<::rust::String>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$balance_of_batch(*this, &account_addresses$.value, &token_ids$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Erc1155::uri(::rust::String token_id) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$uri(
-        *this, &token_id, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$uri(*this, &token_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::org::defi_wallet_core::Erc1155 Erc1155::legacy() noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc1155> return$;
-    org$defi_wallet_core$cxxbridge1$Erc1155$legacy(*this, &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::Erc1155
-Erc1155::interval(::std::uint64_t polling_interval_ms) noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Erc1155> return$;
-    org$defi_wallet_core$cxxbridge1$Erc1155$interval(*this, polling_interval_ms,
-                                                     &return$.value);
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc1155::safe_transfer_from(
-    ::rust::String from_address, ::rust::String to_address,
-    ::rust::String token_id, ::rust::String amount,
-    ::rust::Vec<::std::uint8_t> additional_data,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> additional_data$(
-        ::std::move(additional_data));
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc1155$safe_transfer_from(
-            *this, &from_address, &to_address, &token_id, &amount,
-            &additional_data$.value, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc1155::safe_batch_transfer_from(
-    ::rust::String from_address, ::rust::String to_address,
-    ::rust::Vec<::rust::String> token_ids, ::rust::Vec<::rust::String> amounts,
-    ::rust::Vec<::std::uint8_t> additional_data,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::ManuallyDrop<::rust::Vec<::rust::String>> token_ids$(
-        ::std::move(token_ids));
-    ::rust::ManuallyDrop<::rust::Vec<::rust::String>> amounts$(
-        ::std::move(amounts));
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> additional_data$(
-        ::std::move(additional_data));
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc1155$safe_batch_transfer_from(
-            *this, &from_address, &to_address, &token_ids$.value,
-            &amounts$.value, &additional_data$.value, private_key,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-Erc1155::set_approval_for_all(
-    ::rust::String approved_address, bool approved,
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc1155$set_approval_for_all(
-            *this, &approved_address, approved, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-bool Erc1155::is_approved_for_all(::rust::String owner,
-                                  ::rust::String approved_address) const {
-    ::rust::MaybeUninit<bool> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Erc1155$is_approved_for_all(
-            *this, &owner, &approved_address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc1155> return$;
+  org$defi_wallet_core$cxxbridge1$Erc1155$legacy(*this, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::Erc1155 Erc1155::interval(::std::uint64_t polling_interval_ms) noexcept {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Erc1155> return$;
+  org$defi_wallet_core$cxxbridge1$Erc1155$interval(*this, polling_interval_ms, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc1155::safe_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::rust::String amount, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> additional_data$(::std::move(additional_data));
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$safe_transfer_from(*this, &from_address, &to_address, &token_id, &amount, &additional_data$.value, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc1155::safe_batch_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::Vec<::rust::String> token_ids, ::rust::Vec<::rust::String> amounts, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::ManuallyDrop<::rust::Vec<::rust::String>> token_ids$(::std::move(token_ids));
+  ::rust::ManuallyDrop<::rust::Vec<::rust::String>> amounts$(::std::move(amounts));
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> additional_data$(::std::move(additional_data));
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$safe_batch_transfer_from(*this, &from_address, &to_address, &token_ids$.value, &amounts$.value, &additional_data$.value, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw Erc1155::set_approval_for_all(::rust::String approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$set_approval_for_all(*this, &approved_address, approved, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+bool Erc1155::is_approved_for_all(::rust::String owner, ::rust::String approved_address) const {
+  ::rust::MaybeUninit<bool> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Erc1155$is_approved_for_all(*this, &owner, &approved_address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 } // namespace defi_wallet_core
 } // namespace org
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.h
index 3614f8d3..4a592b76 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/contract.rs.h
@@ -20,575 +20,621 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
 class Opaque;
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_SLICE
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+template <typename T>
+void Slice<T>::swap(Slice &rhs) noexcept {
+  std::swap(*this, rhs);
 }
 #endif // CXXBRIDGE1_RUST_SLICE
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -610,414 +656,370 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct Erc20;
-struct Erc721;
-struct Erc1155;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    struct Erc20;
+    struct Erc721;
+    struct Erc1155;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc20
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc20
 struct Erc20 final {
-    ::rust::String contract_address;
-    ::rust::String web3api_url;
-    bool inner_legacy;
-    ::std::uint64_t inner_polling_interval_ms;
-    ::std::uint64_t chain_id;
-
-    /// Returns the decimal amount of tokens owned by `account_address`.
-    /// # Examples
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338)
-    ///  .legacy();
-    /// U256 = erc20.balance_of("0xf0307093f23311FE6776a7742dB619EB3df62969");
-    /// cout << balance.to_string() << endl;
-    /// ```
-    ::org::defi_wallet_core::U256
-    balance_of(::rust::String account_address) const;
-
-    /// Returns the name of the token
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// String name = erc20.name();
-    /// assert(name == "USDC");
-    /// ```
-    ::rust::String name() const;
-
-    /// Returns the symbol of the token
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// String symbol = erc20.symbol();
-    /// assert(symbol == "USDC");
-    /// ```
-    ::rust::String symbol() const;
-
-    /// Returns the number of decimals the token uses
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338)
-    ///  .legacy();
-    /// uint8_t decimals = erc20.decimals();
-    /// assert(decimals == 6);
-    /// ```
-    ::std::uint8_t decimals() const;
-
-    /// Makes a legacy transaction instead of an EIP-1559 one
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// erc20 = erc20.legacy();
-    /// ```
-    ::org::defi_wallet_core::Erc20 legacy() noexcept;
-
-    /// Sets the default polling interval for event filters and pending
-    /// transactions
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///    "https://evm-dev-t3.cronos.org", 338);
-    /// erc20 = erc20.interval(3000);
-    /// ```
-    ::org::defi_wallet_core::Erc20
-    interval(::std::uint64_t polling_interval_ms) noexcept;
-
-    /// Moves `amount` tokens from the caller’s account to `to_address`.
-    /// # Transfer 100 tokens (devnet)
-    /// ```
-    /// String mycronosrpc = getEnv("MYCRONOSRPC");
-    /// char hdpath[100];
-    /// int cointype = 60;
-    /// int chainid = 777;
-    /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
-    ///
-    /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
-    /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
-    /// String signer1_address = signer1_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
-    ///
-    /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
-    /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
-    /// String signer2_address = signer2_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
-    ///
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.transfer(signer2_address, "100", *privatekey);
-    /// ```
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    transfer(::rust::String to_address, ::rust::String amount,
-             ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Moves `amount` tokens from `from_address` to `to_address` using the
-    /// allowance mechanism. # Transfer from signer1 to validator1 using the
-    /// allowance mechanism (devnet)
-    /// ```
-    /// String mycronosrpc = getEnv("MYCRONOSRPC");
-    /// char hdpath[100];
-    /// int cointype = 60;
-    /// int chainid = 777;
-    /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
-    ///
-    /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
-    /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
-    /// String signer1_address = signer1_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
-    ///
-    /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
-    /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
-    /// String signer2_address = signer2_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
-    ///
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.transfer_from(signer1_address, validator1_address, "100",
-    ///                 *signer2_privatekey);
-    /// ```
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    transfer_from(::rust::String from_address, ::rust::String to_address,
-                  ::rust::String amount,
-                  ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Allows `approved_address` to withdraw from your account multiple times,
-    /// up to the `amount` amount.
-    /// ## approves 1000 allowance (devnet)
-    /// ```
-    /// String mycronosrpc = getEnv("MYCRONOSRPC");
-    /// char hdpath[100];
-    /// int cointype = 60;
-    /// int chainid = 777;
-    /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
-    ///
-    /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
-    /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
-    /// String signer1_address = signer1_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
-    ///
-    /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
-    /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
-    /// String signer2_address = signer2_wallet->get_eth_address(0);
-    /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
-    ///
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.interval(3000).approve(signer2_address, "1000",
-    /// *signer1_privatekey);
-    /// ```
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    approve(::rust::String approved_address, ::rust::String amount,
-            ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Returns the amount which `spender` is still allowed to withdraw from
-    /// `owner`.
-    /// ```
-    /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
-    ///                         mycronosrpc, chainid)
-    ///                 .legacy();
-    /// erc20.allowance(owner, spender);
-    /// ```
-    ::rust::String allowance(::rust::String owner,
-                             ::rust::String spender) const;
-
-    /// Returns the amount of tokens in existence.
-    /// ```
-    /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
-    ///                         "https://evm-dev-t3.cronos.org", 338)
-    ///                 .legacy();
-    /// U256 total_supply = erc20.total_supply();
-    /// ```
-    ::org::defi_wallet_core::U256 total_supply() const;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String contract_address;
+  ::rust::String web3api_url;
+  bool inner_legacy;
+  ::std::uint64_t inner_polling_interval_ms;
+  ::std::uint64_t chain_id;
+
+  /// Returns the decimal amount of tokens owned by `account_address`.
+  /// # Examples
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338)
+  ///  .legacy();
+  /// U256 = erc20.balance_of("0xf0307093f23311FE6776a7742dB619EB3df62969");
+  /// cout << balance.to_string() << endl;
+  /// ```
+  ::org::defi_wallet_core::U256 balance_of(::rust::String account_address) const;
+
+  /// Returns the name of the token
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// String name = erc20.name();
+  /// assert(name == "USDC");
+  /// ```
+  ::rust::String name() const;
+
+  /// Returns the symbol of the token
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// String symbol = erc20.symbol();
+  /// assert(symbol == "USDC");
+  /// ```
+  ::rust::String symbol() const;
+
+  /// Returns the number of decimals the token uses
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338)
+  ///  .legacy();
+  /// uint8_t decimals = erc20.decimals();
+  /// assert(decimals == 6);
+  /// ```
+  ::std::uint8_t decimals() const;
+
+  /// Makes a legacy transaction instead of an EIP-1559 one
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// erc20 = erc20.legacy();
+  /// ```
+  ::org::defi_wallet_core::Erc20 legacy() noexcept;
+
+  /// Sets the default polling interval for event filters and pending transactions
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///    "https://evm-dev-t3.cronos.org", 338);
+  /// erc20 = erc20.interval(3000);
+  /// ```
+  ::org::defi_wallet_core::Erc20 interval(::std::uint64_t polling_interval_ms) noexcept;
+
+  /// Moves `amount` tokens from the caller’s account to `to_address`.
+  /// # Transfer 100 tokens (devnet)
+  /// ```
+  /// String mycronosrpc = getEnv("MYCRONOSRPC");
+  /// char hdpath[100];
+  /// int cointype = 60;
+  /// int chainid = 777;
+  /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
+  ///
+  /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
+  /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
+  /// String signer1_address = signer1_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
+  ///
+  /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
+  /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
+  /// String signer2_address = signer2_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
+  ///
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.transfer(signer2_address, "100", *privatekey);
+  /// ```
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw transfer(::rust::String to_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Moves `amount` tokens from `from_address` to `to_address` using the allowance mechanism.
+  /// # Transfer from signer1 to validator1 using the allowance mechanism (devnet)
+  /// ```
+  /// String mycronosrpc = getEnv("MYCRONOSRPC");
+  /// char hdpath[100];
+  /// int cointype = 60;
+  /// int chainid = 777;
+  /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
+  ///
+  /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
+  /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
+  /// String signer1_address = signer1_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
+  ///
+  /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
+  /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
+  /// String signer2_address = signer2_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
+  ///
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.transfer_from(signer1_address, validator1_address, "100",
+  ///                 *signer2_privatekey);
+  /// ```
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Allows `approved_address` to withdraw from your account multiple times, up to the
+  /// `amount` amount.
+  /// ## approves 1000 allowance (devnet)
+  /// ```
+  /// String mycronosrpc = getEnv("MYCRONOSRPC");
+  /// char hdpath[100];
+  /// int cointype = 60;
+  /// int chainid = 777;
+  /// snprintf(hdpath, sizeof(hdpath), "m/44'/%d'/0'/0/0", cointype);
+  ///
+  /// String signer1_mnemonics = getEnv("SIGNER1_MNEMONIC");
+  /// Box<Wallet> signer1_wallet = createWallet(signer1_mnemonics);
+  /// String signer1_address = signer1_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer1_privatekey = signer1_wallet->get_key(hdpath);
+  ///
+  /// String signer2_mnemonics = getEnv("SIGNER2_MNEMONIC");
+  /// Box<Wallet> signer2_wallet = createWallet(signer2_mnemonics);
+  /// String signer2_address = signer2_wallet->get_eth_address(0);
+  /// Box<PrivateKey> signer2_privatekey = signer2_wallet->get_key(hdpath);
+  ///
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.interval(3000).approve(signer2_address, "1000", *signer1_privatekey);
+  /// ```
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw approve(::rust::String approved_address, ::rust::String amount, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Returns the amount which `spender` is still allowed to withdraw from `owner`.
+  /// ```
+  /// Erc20 erc20 = new_erc20("0x5003c1fcc043D2d81fF970266bf3fa6e8C5a1F3A",
+  ///                         mycronosrpc, chainid)
+  ///                 .legacy();
+  /// erc20.allowance(owner, spender);
+  /// ```
+  ::rust::String allowance(::rust::String owner, ::rust::String spender) const;
+
+  /// Returns the amount of tokens in existence.
+  /// ```
+  /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
+  ///                         "https://evm-dev-t3.cronos.org", 338)
+  ///                 .legacy();
+  /// U256 total_supply = erc20.total_supply();
+  /// ```
+  ::org::defi_wallet_core::U256 total_supply() const;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc20
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc721
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc721
 struct Erc721 final {
-    ::rust::String contract_address;
-    ::rust::String web3api_url;
-    bool inner_legacy;
-    ::std::uint64_t inner_polling_interval_ms;
-    ::std::uint64_t chain_id;
-
-    /// Returns the number of tokens in owner's `account_address`.
-    ///
-    ::org::defi_wallet_core::U256
-    balance_of(::rust::String account_address) const;
-
-    /// Returns the owner of the `token_id` token.
-    ///
-    ::rust::String owner_of(::rust::String token_id) const;
-
-    /// Get the descriptive name for a collection of NFTs in this contract
-    ///
-    ::rust::String name() const;
-
-    /// Get the abbreviated name for NFTs in this contract
-    ///
-    ::rust::String symbol() const;
-
-    /// Get the distinct Uniform Resource Identifier (URI) for a given asset
-    ///
-    ::rust::String token_uri(::rust::String token_id) const;
-
-    /// Makes a legacy transaction instead of an EIP-1559 one
-    ///
-    ::org::defi_wallet_core::Erc721 legacy() noexcept;
-
-    /// Sets the default polling interval for event filters and pending
-    /// transactions
-    ///
-    ::org::defi_wallet_core::Erc721
-    interval(::std::uint64_t polling_interval_ms) noexcept;
-
-    /// Transfers `token_id` token from `from_address` to `to_address`.
-    ///
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    transfer_from(::rust::String from_address, ::rust::String to_address,
-                  ::rust::String token_id,
-                  ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Safely transfers `token_id` token from `from_address` to `to_address`.
-    ///
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::String token_id,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Safely transfers `token_id` token from `from_address` to `to_address`
-    /// with `additional_data`.
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    safe_transfer_from_with_data(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::String token_id, ::rust::Vec<::std::uint8_t> additional_data,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Gives permission to `approved_address` to transfer `token_id` token to
-    /// another account. The approval is cleared when the token is transferred.
-    /// Only a single account can be approved at a time, so approving the zero
-    /// address clears previous approvals.
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    approve(::rust::String approved_address, ::rust::String token_id,
-            ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Enable or disable approval for a third party `approved_address` to
-    /// manage all of sender's assets
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(
-        ::rust::String approved_address, bool approved,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Get the approved address for a single NFT by `token_id`
-    ///
-    ::rust::String get_approved(::rust::String token_id) const;
-
-    /// Query if an address is an authorized `approved_address` for `owner`
-    ///
-    bool is_approved_for_all(::rust::String owner,
-                             ::rust::String approved_address) const;
-
-    /// Returns the total amount of tokens stored by the contract.
-    ///
-    /// From IERC721Enumerable, an optional extension of the standard ERC721
-    ::org::defi_wallet_core::U256 total_supply() const;
-
-    /// Returns a token ID at a given index of all the tokens stored by the
-    /// contract. Use along with totalSupply to enumerate all tokens.
-    ///
-    /// From IERC721Enumerable, an optional extension of the standard ERC721
-    ::rust::String token_by_index(::rust::String index) const;
-
-    /// Returns a token ID owned by owner at a given index of its token list.
-    /// Use along with balanceOf to enumerate all of owner's tokens.
-    ///
-    /// From IERC721Enumerable, an optional extension of the standard ERC721
-    ::rust::String token_of_owner_by_index(::rust::String owner,
-                                           ::rust::String index) const;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String contract_address;
+  ::rust::String web3api_url;
+  bool inner_legacy;
+  ::std::uint64_t inner_polling_interval_ms;
+  ::std::uint64_t chain_id;
+
+  /// Returns the number of tokens in owner's `account_address`.
+  ///
+  ::org::defi_wallet_core::U256 balance_of(::rust::String account_address) const;
+
+  /// Returns the owner of the `token_id` token.
+  ///
+  ::rust::String owner_of(::rust::String token_id) const;
+
+  /// Get the descriptive name for a collection of NFTs in this contract
+  ///
+  ::rust::String name() const;
+
+  /// Get the abbreviated name for NFTs in this contract
+  ///
+  ::rust::String symbol() const;
+
+  /// Get the distinct Uniform Resource Identifier (URI) for a given asset
+  ///
+  ::rust::String token_uri(::rust::String token_id) const;
+
+  /// Makes a legacy transaction instead of an EIP-1559 one
+  ///
+  ::org::defi_wallet_core::Erc721 legacy() noexcept;
+
+  /// Sets the default polling interval for event filters and pending transactions
+  ///
+  ::org::defi_wallet_core::Erc721 interval(::std::uint64_t polling_interval_ms) noexcept;
+
+  /// Transfers `token_id` token from `from_address` to `to_address`.
+  ///
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Safely transfers `token_id` token from `from_address` to `to_address`.
+  ///
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Safely transfers `token_id` token from `from_address` to `to_address` with
+  /// `additional_data`.
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from_with_data(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Gives permission to `approved_address` to transfer `token_id` token to another account.
+  /// The approval is cleared when the token is transferred. Only a single account can be
+  /// approved at a time, so approving the zero address clears previous approvals.
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw approve(::rust::String approved_address, ::rust::String token_id, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Enable or disable approval for a third party `approved_address` to manage all of
+  /// sender's assets
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(::rust::String approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Get the approved address for a single NFT by `token_id`
+  ///
+  ::rust::String get_approved(::rust::String token_id) const;
+
+  /// Query if an address is an authorized `approved_address` for `owner`
+  ///
+  bool is_approved_for_all(::rust::String owner, ::rust::String approved_address) const;
+
+  /// Returns the total amount of tokens stored by the contract.
+  ///
+  /// From IERC721Enumerable, an optional extension of the standard ERC721
+  ::org::defi_wallet_core::U256 total_supply() const;
+
+  /// Returns a token ID at a given index of all the tokens stored by the contract. Use along
+  /// with totalSupply to enumerate all tokens.
+  ///
+  /// From IERC721Enumerable, an optional extension of the standard ERC721
+  ::rust::String token_by_index(::rust::String index) const;
+
+  /// Returns a token ID owned by owner at a given index of its token list. Use along with
+  /// balanceOf to enumerate all of owner's tokens.
+  ///
+  /// From IERC721Enumerable, an optional extension of the standard ERC721
+  ::rust::String token_of_owner_by_index(::rust::String owner, ::rust::String index) const;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc721
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc1155
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc1155
 struct Erc1155 final {
-    ::rust::String contract_address;
-    ::rust::String web3api_url;
-    bool inner_legacy;
-    ::std::uint64_t inner_polling_interval_ms;
-    ::std::uint64_t chain_id;
-
-    /// Returns the amount of tokens of `token_id` owned by `account_address`.
-    ///
-    ::org::defi_wallet_core::U256 balance_of(::rust::String account_address,
-                                             ::rust::String token_id) const;
-
-    /// Batched version of balance_of.
-    /// Get the balance of multiple account/token pairs
-    ::rust::Vec<::rust::String>
-    balance_of_batch(::rust::Vec<::rust::String> account_addresses,
-                     ::rust::Vec<::rust::String> token_ids) const;
-
-    /// Get distinct Uniform Resource Identifier (URI) for a given token
-    ///
-    ::rust::String uri(::rust::String token_id) const;
-
-    /// Makes a legacy transaction instead of an EIP-1559 one
-    ///
-    ::org::defi_wallet_core::Erc1155 legacy() noexcept;
-
-    /// Sets the default polling interval for event filters and pending
-    /// transactions
-    ///
-    ::org::defi_wallet_core::Erc1155
-    interval(::std::uint64_t polling_interval_ms) noexcept;
-
-    /// Transfers `amount` tokens of `token_id` from `from_address` to
-    /// `to_address` with `additional_data`.
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::String token_id, ::rust::String amount,
-        ::rust::Vec<::std::uint8_t> additional_data,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Batched version of safeTransferFrom.
-    ///
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    safe_batch_transfer_from(
-        ::rust::String from_address, ::rust::String to_address,
-        ::rust::Vec<::rust::String> token_ids,
-        ::rust::Vec<::rust::String> amounts,
-        ::rust::Vec<::std::uint8_t> additional_data,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Enable or disable approval for a third party `approved_address` to
-    /// manage all of sender's assets
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(
-        ::rust::String approved_address, bool approved,
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Query if an address is an authorized `approved_address` for `owner`
-    ///
-    bool is_approved_for_all(::rust::String owner,
-                             ::rust::String approved_address) const;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String contract_address;
+  ::rust::String web3api_url;
+  bool inner_legacy;
+  ::std::uint64_t inner_polling_interval_ms;
+  ::std::uint64_t chain_id;
+
+  /// Returns the amount of tokens of `token_id` owned by `account_address`.
+  ///
+  ::org::defi_wallet_core::U256 balance_of(::rust::String account_address, ::rust::String token_id) const;
+
+  /// Batched version of balance_of.
+  /// Get the balance of multiple account/token pairs
+  ::rust::Vec<::rust::String> balance_of_batch(::rust::Vec<::rust::String> account_addresses, ::rust::Vec<::rust::String> token_ids) const;
+
+  /// Get distinct Uniform Resource Identifier (URI) for a given token
+  ///
+  ::rust::String uri(::rust::String token_id) const;
+
+  /// Makes a legacy transaction instead of an EIP-1559 one
+  ///
+  ::org::defi_wallet_core::Erc1155 legacy() noexcept;
+
+  /// Sets the default polling interval for event filters and pending transactions
+  ///
+  ::org::defi_wallet_core::Erc1155 interval(::std::uint64_t polling_interval_ms) noexcept;
+
+  /// Transfers `amount` tokens of `token_id` from `from_address` to `to_address` with
+  /// `additional_data`.
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::String token_id, ::rust::String amount, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Batched version of safeTransferFrom.
+  ///
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw safe_batch_transfer_from(::rust::String from_address, ::rust::String to_address, ::rust::Vec<::rust::String> token_ids, ::rust::Vec<::rust::String> amounts, ::rust::Vec<::std::uint8_t> additional_data, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Enable or disable approval for a third party `approved_address` to manage all of
+  /// sender's assets
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw set_approval_for_all(::rust::String approved_address, bool approved, ::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Query if an address is an authorized `approved_address` for `owner`
+  ///
+  bool is_approved_for_all(::rust::String owner, ::rust::String approved_address) const;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Erc1155
 
@@ -1026,20 +1028,14 @@ struct Erc1155 final {
 /// Erc20 erc20 = new_erc20("0xf0307093f23311FE6776a7742dB619EB3df62969",
 ///    "https://evm-dev-t3.cronos.org", 338);
 /// ```
-::org::defi_wallet_core::Erc20 new_erc20(::rust::String address,
-                                         ::rust::String web3api_url,
-                                         ::std::uint64_t chian_id) noexcept;
+::org::defi_wallet_core::Erc20 new_erc20(::rust::String address, ::rust::String web3api_url, ::std::uint64_t chian_id) noexcept;
 
 /// Construct an Erc721 struct
 ///
-::org::defi_wallet_core::Erc721 new_erc721(::rust::String address,
-                                           ::rust::String web3api_url,
-                                           ::std::uint64_t chian_id) noexcept;
+::org::defi_wallet_core::Erc721 new_erc721(::rust::String address, ::rust::String web3api_url, ::std::uint64_t chian_id) noexcept;
 
 /// Construct an Erc1155 struct
 ///
-::org::defi_wallet_core::Erc1155 new_erc1155(::rust::String address,
-                                             ::rust::String web3api_url,
-                                             ::std::uint64_t chian_id) noexcept;
+::org::defi_wallet_core::Erc1155 new_erc1155(::rust::String address, ::rust::String web3api_url, ::std::uint64_t chian_id) noexcept;
 } // namespace defi_wallet_core
 } // namespace org
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/core.cc b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/core.cc
index 9d68f99a..4f2d0a42 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/core.cc
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/core.cc
@@ -19,755 +19,822 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_STR
 #define CXXBRIDGE1_RUST_STR
 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;
-
-    const char *data() const noexcept;
-    std::size_t size() const noexcept;
-    std::size_t length() const noexcept;
-    bool empty() const noexcept;
-
-    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;
+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;
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  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
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -777,31 +844,31 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_ERROR
 #define CXXBRIDGE1_RUST_ERROR
 class Error final : public std::exception {
-  public:
-    Error(const Error &);
-    Error(Error &&) noexcept;
-    ~Error() noexcept override;
+public:
+  Error(const Error &);
+  Error(Error &&) noexcept;
+  ~Error() noexcept override;
 
-    Error &operator=(const Error &) &;
-    Error &operator=(Error &&) &noexcept;
+  Error &operator=(const Error &) &;
+  Error &operator=(Error &&) &noexcept;
 
-    const char *what() const noexcept override;
+  const char *what() const noexcept override;
 
-  private:
-    Error() noexcept = default;
-    friend impl<Error>;
-    const char *msg;
-    std::size_t len;
+private:
+  Error() noexcept = default;
+  friend impl<Error>;
+  const char *msg;
+  std::size_t len;
 };
 #endif // CXXBRIDGE1_RUST_ERROR
 
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -820,57 +887,69 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_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>
+struct make_void {
+  using type = void;
+};
 
-template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
 
 template <typename Void, template <typename...> class, typename...>
 struct detect : std::false_type {};
@@ -880,7 +959,8 @@ 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>
+using detect_IsRelocatable = typename T::IsRelocatable;
 
 template <typename T>
 struct get_IsRelocatable
@@ -899,1271 +979,935 @@ struct IsRelocatable
 
 namespace repr {
 struct PtrLen final {
-    void *ptr;
-    ::std::size_t len;
+  void *ptr;
+  ::std::size_t len;
 };
 } // namespace repr
 
 namespace detail {
-template <typename T, typename = void *> struct operator_new {
-    void *operator()(::std::size_t sz) { return ::operator new(sz); }
+template <typename T, typename = void *>
+struct operator_new {
+  void *operator()(::std::size_t sz) { return ::operator new(sz); }
 };
 
 template <typename T>
 struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
-    void *operator()(::std::size_t sz) { return T::operator new(sz); }
+  void *operator()(::std::size_t sz) { return T::operator new(sz); }
 };
 } // namespace detail
 
-template <typename T> union ManuallyDrop {
-    T value;
-    ManuallyDrop(T &&value) : value(::std::move(value)) {}
-    ~ManuallyDrop() {}
+template <typename T>
+union ManuallyDrop {
+  T value;
+  ManuallyDrop(T &&value) : value(::std::move(value)) {}
+  ~ManuallyDrop() {}
 };
 
-template <typename T> union MaybeUninit {
-    T value;
-    void *operator new(::std::size_t sz) {
-        return detail::operator_new<T>{}(sz);
-    }
-    MaybeUninit() {}
-    ~MaybeUninit() {}
+template <typename T>
+union MaybeUninit {
+  T value;
+  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
+  MaybeUninit() {}
+  ~MaybeUninit() {}
 };
 
 namespace {
-template <> class impl<Error> final {
-  public:
-    static Error error(repr::PtrLen repr) noexcept {
-        Error error;
-        error.msg = static_cast<char const *>(repr.ptr);
-        error.len = repr.len;
-        return error;
-    }
+template <>
+class impl<Error> final {
+public:
+  static Error error(repr::PtrLen repr) noexcept {
+    Error error;
+    error.msg = static_cast<char const *>(repr.ptr);
+    error.len = repr.len;
+    return error;
+  }
 };
 } // namespace
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-enum class CoinType : ::std::uint8_t;
-enum class MnemonicWordCount : ::std::uint8_t;
-enum class EthAmount : ::std::uint8_t;
-struct EthTxInfoRaw;
-struct CosmosSDKTxInfoRaw;
-struct CosmosAccountInfoRaw;
-struct CosmosTransactionReceiptRaw;
-struct CronosTransactionReceiptRaw;
-struct PrivateKey;
-struct CosmosSDKMsgRaw;
-struct Wallet;
-struct CppLoginInfo;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    enum class CoinType : ::std::uint8_t;
+    enum class MnemonicWordCount : ::std::uint8_t;
+    enum class EthAmount : ::std::uint8_t;
+    struct EthTxInfoRaw;
+    struct CosmosSDKTxInfoRaw;
+    struct CosmosAccountInfoRaw;
+    struct CosmosTransactionReceiptRaw;
+    struct CronosTransactionReceiptRaw;
+    struct PrivateKey;
+    struct CosmosSDKMsgRaw;
+    struct Wallet;
+    struct CppLoginInfo;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_ENUM_org$defi_wallet_core$CoinType
 #define CXXBRIDGE1_ENUM_org$defi_wallet_core$CoinType
 enum class CoinType : ::std::uint8_t {
-    /// Crypto.org Chain mainnet
-    ///
-    CryptoOrgMainnet = 0,
-    /// Crypto.org Chain testnet
-    ///
-    CryptoOrgTestnet = 1,
-    /// Cronos mainnet beta
-    ///
-    CronosMainnet = 2,
-    /// Cosmos Hub mainnet
-    ///
-    CosmosHub = 3,
-    /// Ethereum
-    ///
-    Ethereum = 4,
+  /// Crypto.org Chain mainnet
+  ///
+  CryptoOrgMainnet = 0,
+  /// Crypto.org Chain testnet
+  ///
+  CryptoOrgTestnet = 1,
+  /// Cronos mainnet beta
+  ///
+  CronosMainnet = 2,
+  /// Cosmos Hub mainnet
+  ///
+  CosmosHub = 3,
+  /// Ethereum
+  ///
+  Ethereum = 4,
 };
 #endif // CXXBRIDGE1_ENUM_org$defi_wallet_core$CoinType
 
 #ifndef CXXBRIDGE1_ENUM_org$defi_wallet_core$MnemonicWordCount
 #define CXXBRIDGE1_ENUM_org$defi_wallet_core$MnemonicWordCount
 enum class MnemonicWordCount : ::std::uint8_t {
-    /// Word 12
-    ///
-    Twelve = 0,
-    /// Word 18
-    ///
-    Eighteen = 1,
-    /// Word 24
-    ///
-    TwentyFour = 2,
+  /// Word 12
+  ///
+  Twelve = 0,
+  /// Word 18
+  ///
+  Eighteen = 1,
+  /// Word 24
+  ///
+  TwentyFour = 2,
 };
 #endif // CXXBRIDGE1_ENUM_org$defi_wallet_core$MnemonicWordCount
 
 #ifndef CXXBRIDGE1_ENUM_org$defi_wallet_core$EthAmount
 #define CXXBRIDGE1_ENUM_org$defi_wallet_core$EthAmount
 enum class EthAmount : ::std::uint8_t {
-    /// 10^-18 ETH
-    ///
-    WeiDecimal = 0,
-    /// 10^-9 ETH
-    ///
-    GweiDecimal = 1,
-    EthDecimal = 2,
+  /// 10^-18 ETH
+  ///
+  WeiDecimal = 0,
+  /// 10^-9 ETH
+  ///
+  GweiDecimal = 1,
+  EthDecimal = 2,
 };
 #endif // CXXBRIDGE1_ENUM_org$defi_wallet_core$EthAmount
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthTxInfoRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthTxInfoRaw
 struct EthTxInfoRaw final {
-    ::rust::String to_address;
-    ::rust::String amount;
-    ::org::defi_wallet_core::EthAmount amount_unit;
-    ::rust::String nonce;
-    ::rust::String gas_limit;
-    ::rust::String gas_price;
-    ::org::defi_wallet_core::EthAmount gas_price_unit;
-    ::rust::Vec<::std::uint8_t> data;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_address;
+  ::rust::String amount;
+  ::org::defi_wallet_core::EthAmount amount_unit;
+  ::rust::String nonce;
+  ::rust::String gas_limit;
+  ::rust::String gas_price;
+  ::org::defi_wallet_core::EthAmount gas_price_unit;
+  ::rust::Vec<::std::uint8_t> data;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthTxInfoRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKTxInfoRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKTxInfoRaw
 struct CosmosSDKTxInfoRaw final {
-    /// global account number of the sender
-    ///
-    ::std::uint64_t account_number;
-    /// equivalent of "account nonce"
-    ///
-    ::std::uint64_t sequence_number;
-    /// the maximum gas limit
-    ///
-    ::std::uint64_t gas_limit;
-    /// the amount fee to be paid (gas_limit * gas_price)
-    ///
-    ::std::uint64_t fee_amount;
-    /// the fee's denomination
-    ///
-    ::rust::String fee_denom;
-    /// transaction timeout
-    ///
-    ::std::uint32_t timeout_height;
-    /// optional memo
-    ///
-    ::rust::String memo_note;
-    /// the network chain id
-    ///
-    ::rust::String chain_id;
-    /// bech32 human readable prefix
-    ///
-    ::rust::String bech32hrp;
-    /// the coin type to use
-    ///
-    ::std::uint32_t coin_type;
-
-    using IsRelocatable = ::std::true_type;
+  /// global account number of the sender
+  ///
+  ::std::uint64_t account_number;
+  /// equivalent of "account nonce"
+  ///
+  ::std::uint64_t sequence_number;
+  /// the maximum gas limit
+  ///
+  ::std::uint64_t gas_limit;
+  /// the amount fee to be paid (gas_limit * gas_price)
+  ///
+  ::std::uint64_t fee_amount;
+  /// the fee's denomination
+  ///
+  ::rust::String fee_denom;
+  /// transaction timeout
+  ///
+  ::std::uint32_t timeout_height;
+  /// optional memo
+  ///
+  ::rust::String memo_note;
+  /// the network chain id
+  ///
+  ::rust::String chain_id;
+  /// bech32 human readable prefix
+  ///
+  ::rust::String bech32hrp;
+  /// the coin type to use
+  ///
+  ::std::uint32_t coin_type;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKTxInfoRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosAccountInfoRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosAccountInfoRaw
 struct CosmosAccountInfoRaw final {
-    ::std::uint64_t account_number;
-    ::std::uint64_t sequence_number;
+  ::std::uint64_t account_number;
+  ::std::uint64_t sequence_number;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosAccountInfoRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosTransactionReceiptRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosTransactionReceiptRaw
 struct CosmosTransactionReceiptRaw final {
-    /// tendermint transaction hash in hexadecimal
-    ///
-    ::rust::String tx_hash_hex;
-    /// error code (0 if success)
-    ///
-    ::std::uint32_t code;
-    /// possible error log
-    ///
-    ::rust::String log;
-
-    using IsRelocatable = ::std::true_type;
+  /// tendermint transaction hash in hexadecimal
+  ///
+  ::rust::String tx_hash_hex;
+  /// error code (0 if success)
+  ///
+  ::std::uint32_t code;
+  /// possible error log
+  ///
+  ::rust::String log;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosTransactionReceiptRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CronosTransactionReceiptRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CronosTransactionReceiptRaw
 struct CronosTransactionReceiptRaw final {
-    ::rust::Vec<::std::uint8_t> transaction_hash;
-    ::rust::String transaction_index;
-    ::rust::Vec<::std::uint8_t> block_hash;
-    ::rust::String block_number;
-    ::rust::String cumulative_gas_used;
-    ::rust::String gas_used;
-    ::rust::String contract_address;
-    ::rust::Vec<::rust::String> logs;
-    /// Status: either 1 (success) or 0 (failure)
-    ///
-    ::rust::String status;
-    ::rust::Vec<::std::uint8_t> root;
-    ::rust::Vec<::std::uint8_t> logs_bloom;
-    ::rust::String transaction_type;
-    ::rust::String effective_gas_price;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::Vec<::std::uint8_t> transaction_hash;
+  ::rust::String transaction_index;
+  ::rust::Vec<::std::uint8_t> block_hash;
+  ::rust::String block_number;
+  ::rust::String cumulative_gas_used;
+  ::rust::String gas_used;
+  ::rust::String contract_address;
+  ::rust::Vec<::rust::String> logs;
+  /// Status: either 1 (success) or 0 (failure)
+  ///
+  ::rust::String status;
+  ::rust::Vec<::std::uint8_t> root;
+  ::rust::Vec<::std::uint8_t> logs_bloom;
+  ::rust::String transaction_type;
+  ::rust::String effective_gas_price;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CronosTransactionReceiptRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$PrivateKey
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$PrivateKey
 struct PrivateKey final : public ::rust::Opaque {
-    ~PrivateKey() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ~PrivateKey() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$PrivateKey
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKMsgRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKMsgRaw
 struct CosmosSDKMsgRaw final : public ::rust::Opaque {
-    ~CosmosSDKMsgRaw() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ~CosmosSDKMsgRaw() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKMsgRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Wallet
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Wallet
 struct Wallet final : public ::rust::Opaque {
-    /// get backup mnemonic phrase
-    ///
-    ::rust::String get_backup_mnemonic_phrase() const;
-
-    /// returns the default address of the wallet
-    ///
-    ::rust::String
-    get_default_address(::org::defi_wallet_core::CoinType coin) const;
-
-    /// returns the address from index in wallet
-    ///
-    ::rust::String get_address(::org::defi_wallet_core::CoinType coin,
-                               ::std::uint32_t index) const;
-
-    /// returns the ethereum address from index in wallet
-    ///
-    ::rust::String get_eth_address(::std::uint32_t index) const;
-
-    /// return the secret key for a given derivation path
-    ///
-    ::rust::Box<::org::defi_wallet_core::PrivateKey>
-    get_key(::rust::String derivation_path) const;
-
-    ~Wallet() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// get backup mnemonic phrase
+  ///
+  ::rust::String get_backup_mnemonic_phrase() const;
+
+  /// returns the default address of the wallet
+  ///
+  ::rust::String get_default_address(::org::defi_wallet_core::CoinType coin) const;
+
+  /// returns the address from index in wallet
+  ///
+  ::rust::String get_address(::org::defi_wallet_core::CoinType coin, ::std::uint32_t index) const;
+
+  /// returns the ethereum address from index in wallet
+  ///
+  ::rust::String get_eth_address(::std::uint32_t index) const;
+
+  /// return the secret key for a given derivation path
+  ///
+  ::rust::Box<::org::defi_wallet_core::PrivateKey> get_key(::rust::String derivation_path) const;
+
+  ~Wallet() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Wallet
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CppLoginInfo
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CppLoginInfo
 struct CppLoginInfo final : public ::rust::Opaque {
-    /// Sign Login Info
-    /// constructs the plaintext message and signs it according to EIP-191
-    /// (as per EIP-4361). The returned vector is a serialized recoverable
-    /// signature (as used in Ethereum).
-    ::rust::Vec<::std::uint8_t> sign_logininfo(
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Verify Login Info
-    /// It verified the signature matches + also verifies the content of the
-    /// message:
-    /// - address in the message matches the address recovered from the
-    /// signature
-    /// - the time is valid
-    /// ...
-    /// NOTE: the server may still need to do extra verifications according to
-    /// its needs (e.g. verify chain-id, nonce, uri + possibly fetch additional
-    /// data associated with the given Ethereum address, such as
-    /// ERC-20/ERC-721/ERC-1155 asset ownership)
-    void verify_logininfo(::rust::Slice<::std::uint8_t const> signature) const;
-
-    ~CppLoginInfo() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// Sign Login Info
+  /// constructs the plaintext message and signs it according to EIP-191
+  /// (as per EIP-4361). The returned vector is a serialized recoverable signature
+  /// (as used in Ethereum).
+  ::rust::Vec<::std::uint8_t> sign_logininfo(::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Verify Login Info
+  /// It verified the signature matches + also verifies the content of the message:
+  /// - address in the message matches the address recovered from the signature
+  /// - the time is valid
+  /// ...
+  /// NOTE: the server may still need to do extra verifications according to its needs
+  /// (e.g. verify chain-id, nonce, uri + possibly fetch additional data associated
+  /// with the given Ethereum address, such as ERC-20/ERC-721/ERC-1155 asset ownership)
+  void verify_logininfo(::rust::Slice<::std::uint8_t const> signature) const;
+
+  ~CppLoginInfo() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CppLoginInfo
 } // namespace defi_wallet_core
 } // namespace org
 
-static_assert(::rust::IsRelocatable<::org::defi_wallet_core::U256>::value,
-              "type org::defi_wallet_core::U256 should be trivially move "
-              "constructible and trivially destructible in C++ to be used as a "
-              "return value of `get_eth_balance` in Rust");
+static_assert(
+    ::rust::IsRelocatable<::org::defi_wallet_core::U256>::value,
+    "type org::defi_wallet_core::U256 should be trivially move constructible and trivially destructible in C++ to be used as a return value of `get_eth_balance` in Rust");
 
 namespace org {
 namespace defi_wallet_core {
 extern "C" {
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$query_account_details(
-    ::rust::String *api_url, ::rust::String *address,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$query_account_details_info(
-    ::rust::String *api_url, ::rust::String *address,
-    ::org::defi_wallet_core::CosmosAccountInfoRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$broadcast_tx(
-    ::rust::String *tendermint_rpc_url,
-    ::rust::Vec<::std::uint8_t> *raw_signed_tx,
-    ::org::defi_wallet_core::CosmosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$query_account_balance(
-    ::rust::String *grpc_url, ::rust::String *address, ::rust::String *denom,
-    ::rust::String *return$) noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$PrivateKey$operator$sizeof() noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$PrivateKey$operator$alignof() noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$sizeof() noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$alignof() noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_msg_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::org::defi_wallet_core::CosmosSDKMsgRaw const &msg,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_single_bank_send_signdoc(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::rust::Vec<::std::uint8_t> *sender_pubkey,
-    ::rust::String *recipient_address, ::std::uint64_t amount,
-    ::rust::String *denom, ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_single_bank_send_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String *recipient_address, ::std::uint64_t amount,
-    ::rust::String *denom, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$query_account_details(::rust::String *api_url, ::rust::String *address, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$query_account_details_info(::rust::String *api_url, ::rust::String *address, ::org::defi_wallet_core::CosmosAccountInfoRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$broadcast_tx(::rust::String *tendermint_rpc_url, ::rust::Vec<::std::uint8_t> *raw_signed_tx, ::org::defi_wallet_core::CosmosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$query_account_balance(::rust::String *grpc_url, ::rust::String *address, ::rust::String *denom, ::rust::String *return$) noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$PrivateKey$operator$sizeof() noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$PrivateKey$operator$alignof() noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$sizeof() noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$alignof() noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_msg_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CosmosSDKMsgRaw const &msg, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_single_bank_send_signdoc(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::rust::Vec<::std::uint8_t> *sender_pubkey, ::rust::String *recipient_address, ::std::uint64_t amount, ::rust::String *denom, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_single_bank_send_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *recipient_address, ::std::uint64_t amount, ::rust::String *denom, ::rust::Vec<::std::uint8_t> *return$) noexcept;
 ::std::size_t org$defi_wallet_core$cxxbridge1$Wallet$operator$sizeof() noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$Wallet$operator$alignof() noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_wallet(
-    ::rust::String *password,
-    ::org::defi_wallet_core::MnemonicWordCount word_count,
-    ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$Wallet$get_backup_mnemonic_phrase(
-    ::org::defi_wallet_core::Wallet const &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$generate_mnemonics(
-    ::rust::String *password,
-    ::org::defi_wallet_core::MnemonicWordCount word_count,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$restore_wallet_save_to_securestorage(
-    ::rust::String *mnemonic, ::rust::String *password,
-    ::rust::String *servicename, ::rust::String *username,
-    ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$restore_wallet_load_from_securestorage(
-    ::rust::String *servicename, ::rust::String *username,
-    ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$restore_wallet(
-    ::rust::String *mnemonic, ::rust::String *password,
-    ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_default_address(
-    ::org::defi_wallet_core::Wallet const &self,
-    ::org::defi_wallet_core::CoinType coin, ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_address(
-    ::org::defi_wallet_core::Wallet const &self,
-    ::org::defi_wallet_core::CoinType coin, ::std::uint32_t index,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_eth_address(
-    ::org::defi_wallet_core::Wallet const &self, ::std::uint32_t index,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_key(
-    ::org::defi_wallet_core::Wallet const &self,
-    ::rust::String *derivation_path,
-    ::rust::Box<::org::defi_wallet_core::PrivateKey> *return$) noexcept;
-
-::org::defi_wallet_core::PrivateKey *
-org$defi_wallet_core$cxxbridge1$new_privatekey() noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_privatekey_from_bytes(
-    ::rust::Vec<::std::uint8_t> *bytes,
-    ::rust::Box<::org::defi_wallet_core::PrivateKey> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_privatekey_from_hex(
-    ::rust::String *hex,
-    ::rust::Box<::org::defi_wallet_core::PrivateKey> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_staking_delegate_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String *validator_address, ::std::uint64_t amount,
-    ::rust::String *denom, bool with_reward_withdrawal,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_staking_redelegate_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String *validator_src_address,
-    ::rust::String *validator_dst_address, ::std::uint64_t amount,
-    ::rust::String *denom, bool with_reward_withdrawal,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_staking_unbond_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String *validator_address, ::std::uint64_t amount,
-    ::rust::String *denom, bool with_reward_withdrawal,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_distribution_set_withdraw_address_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String *withdraw_address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_distribution_withdraw_reward_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String *validator_address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_ibc_transfer_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String *receiver, ::rust::String *source_port,
-    ::rust::String *source_channel, ::rust::String *denom,
-    ::std::uint64_t token, ::std::uint64_t revision_height,
-    ::std::uint64_t revision_number, ::std::uint64_t timeout_timestamp,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$sizeof() noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$alignof() noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_logininfo(
-    ::rust::String *msg,
-    ::rust::Box<::org::defi_wallet_core::CppLoginInfo> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$CppLoginInfo$sign_logininfo(
-    ::org::defi_wallet_core::CppLoginInfo const &self,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$CppLoginInfo$verify_logininfo(
-    ::org::defi_wallet_core::CppLoginInfo const &self,
-    ::rust::Slice<::std::uint8_t const> signature) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$new_eth_tx_info(
-    ::org::defi_wallet_core::EthTxInfoRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$build_eth_signed_tx(
-    ::org::defi_wallet_core::EthTxInfoRaw *tx_info, ::rust::Str network,
-    ::org::defi_wallet_core::PrivateKey const &secret_key,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$build_custom_eth_signed_tx(
-    ::org::defi_wallet_core::EthTxInfoRaw *tx_info, ::std::uint64_t chain_id,
-    bool legacy, ::org::defi_wallet_core::PrivateKey const &secret_key,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_eth_balance(
-    ::rust::Str address, ::rust::Str api_url,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_eth_nonce(
-    ::rust::Str address, ::rust::Str api_url, ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_block_number_blocking(
-    ::rust::String *api_url, ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_vec_blocking(
-    ::rust::Vec<::std::uint8_t> *tx_hash, ::rust::String *api_url,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_string_blocking(
-    ::rust::String *tx_hash, ::rust::String *api_url,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_vec_blocking(
-    ::rust::Vec<::std::uint8_t> *tx_hash, ::rust::String *api_url,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_string_blocking(
-    ::rust::String *tx_hash, ::rust::String *api_url,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$broadcast_eth_signed_raw_tx(
-    ::rust::Vec<::std::uint8_t> *raw_tx, ::rust::Str web3api_url,
-    ::std::uint64_t polling_interval_ms,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$set_cronos_httpagent(
-    ::rust::Str agent) noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$Wallet$operator$alignof() noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_wallet(::rust::String *password, ::org::defi_wallet_core::MnemonicWordCount word_count, ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_backup_mnemonic_phrase(::org::defi_wallet_core::Wallet const &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$generate_mnemonics(::rust::String *password, ::org::defi_wallet_core::MnemonicWordCount word_count, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$restore_wallet_save_to_securestorage(::rust::String *mnemonic, ::rust::String *password, ::rust::String *servicename, ::rust::String *username, ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$restore_wallet_load_from_securestorage(::rust::String *servicename, ::rust::String *username, ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$restore_wallet(::rust::String *mnemonic, ::rust::String *password, ::rust::Box<::org::defi_wallet_core::Wallet> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_default_address(::org::defi_wallet_core::Wallet const &self, ::org::defi_wallet_core::CoinType coin, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_address(::org::defi_wallet_core::Wallet const &self, ::org::defi_wallet_core::CoinType coin, ::std::uint32_t index, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_eth_address(::org::defi_wallet_core::Wallet const &self, ::std::uint32_t index, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$Wallet$get_key(::org::defi_wallet_core::Wallet const &self, ::rust::String *derivation_path, ::rust::Box<::org::defi_wallet_core::PrivateKey> *return$) noexcept;
+
+::org::defi_wallet_core::PrivateKey *org$defi_wallet_core$cxxbridge1$new_privatekey() noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_privatekey_from_bytes(::rust::Vec<::std::uint8_t> *bytes, ::rust::Box<::org::defi_wallet_core::PrivateKey> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_privatekey_from_hex(::rust::String *hex, ::rust::Box<::org::defi_wallet_core::PrivateKey> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_staking_delegate_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *validator_address, ::std::uint64_t amount, ::rust::String *denom, bool with_reward_withdrawal, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_staking_redelegate_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *validator_src_address, ::rust::String *validator_dst_address, ::std::uint64_t amount, ::rust::String *denom, bool with_reward_withdrawal, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_staking_unbond_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *validator_address, ::std::uint64_t amount, ::rust::String *denom, bool with_reward_withdrawal, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_distribution_set_withdraw_address_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *withdraw_address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_distribution_withdraw_reward_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *validator_address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_ibc_transfer_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *receiver, ::rust::String *source_port, ::rust::String *source_channel, ::rust::String *denom, ::std::uint64_t token, ::std::uint64_t revision_height, ::std::uint64_t revision_number, ::std::uint64_t timeout_timestamp, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$sizeof() noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$alignof() noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_logininfo(::rust::String *msg, ::rust::Box<::org::defi_wallet_core::CppLoginInfo> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$CppLoginInfo$sign_logininfo(::org::defi_wallet_core::CppLoginInfo const &self, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$CppLoginInfo$verify_logininfo(::org::defi_wallet_core::CppLoginInfo const &self, ::rust::Slice<::std::uint8_t const> signature) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$new_eth_tx_info(::org::defi_wallet_core::EthTxInfoRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw *tx_info, ::rust::Str network, ::org::defi_wallet_core::PrivateKey const &secret_key, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$build_custom_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw *tx_info, ::std::uint64_t chain_id, bool legacy, ::org::defi_wallet_core::PrivateKey const &secret_key, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_eth_balance(::rust::Str address, ::rust::Str api_url, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_eth_nonce(::rust::Str address, ::rust::Str api_url, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_block_number_blocking(::rust::String *api_url, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_vec_blocking(::rust::Vec<::std::uint8_t> *tx_hash, ::rust::String *api_url, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_string_blocking(::rust::String *tx_hash, ::rust::String *api_url, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_vec_blocking(::rust::Vec<::std::uint8_t> *tx_hash, ::rust::String *api_url, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_string_blocking(::rust::String *tx_hash, ::rust::String *api_url, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$broadcast_eth_signed_raw_tx(::rust::Vec<::std::uint8_t> *raw_tx, ::rust::Str web3api_url, ::std::uint64_t polling_interval_ms, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$set_cronos_httpagent(::rust::Str agent) noexcept;
 } // extern "C"
 
 /// query account details from cosmos address
 ///
-::rust::String query_account_details(::rust::String api_url,
-                                     ::rust::String address) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$query_account_details(
-            &api_url, &address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::String query_account_details(::rust::String api_url, ::rust::String address) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$query_account_details(&api_url, &address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// query account details info from cosmos address
 ///
-::org::defi_wallet_core::CosmosAccountInfoRaw
-query_account_details_info(::rust::String api_url, ::rust::String address) {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CosmosAccountInfoRaw> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$query_account_details_info(
-            &api_url, &address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::CosmosAccountInfoRaw query_account_details_info(::rust::String api_url, ::rust::String address) {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CosmosAccountInfoRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$query_account_details_info(&api_url, &address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// broadcast the cosmos transaction
 ///
-::org::defi_wallet_core::CosmosTransactionReceiptRaw
-broadcast_tx(::rust::String tendermint_rpc_url,
-             ::rust::Vec<::std::uint8_t> raw_signed_tx) {
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> raw_signed_tx$(
-        ::std::move(raw_signed_tx));
-    ::rust::MaybeUninit<::org::defi_wallet_core::CosmosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$broadcast_tx(
-        &tendermint_rpc_url, &raw_signed_tx$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::CosmosTransactionReceiptRaw broadcast_tx(::rust::String tendermint_rpc_url, ::rust::Vec<::std::uint8_t> raw_signed_tx) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> raw_signed_tx$(::std::move(raw_signed_tx));
+  ::rust::MaybeUninit<::org::defi_wallet_core::CosmosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$broadcast_tx(&tendermint_rpc_url, &raw_signed_tx$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// query account balance from cosmos address and denom name
 ///
-::rust::String query_account_balance(::rust::String grpc_url,
-                                     ::rust::String address,
-                                     ::rust::String denom) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$query_account_balance(
-            &grpc_url, &address, &denom, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::String query_account_balance(::rust::String grpc_url, ::rust::String address, ::rust::String denom) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$query_account_balance(&grpc_url, &address, &denom, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::std::size_t PrivateKey::layout::size() noexcept {
-    return org$defi_wallet_core$cxxbridge1$PrivateKey$operator$sizeof();
+  return org$defi_wallet_core$cxxbridge1$PrivateKey$operator$sizeof();
 }
 
 ::std::size_t PrivateKey::layout::align() noexcept {
-    return org$defi_wallet_core$cxxbridge1$PrivateKey$operator$alignof();
+  return org$defi_wallet_core$cxxbridge1$PrivateKey$operator$alignof();
 }
 
 ::std::size_t CosmosSDKMsgRaw::layout::size() noexcept {
-    return org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$sizeof();
+  return org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$sizeof();
 }
 
 ::std::size_t CosmosSDKMsgRaw::layout::align() noexcept {
-    return org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$alignof();
+  return org$defi_wallet_core$cxxbridge1$CosmosSDKMsgRaw$operator$alignof();
 }
 
 /// creates the signed transaction for cosmos
 ///
-::rust::Vec<::std::uint8_t>
-get_msg_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                  ::org::defi_wallet_core::PrivateKey const &private_key,
-                  ::org::defi_wallet_core::CosmosSDKMsgRaw const &msg) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_msg_signed_tx(
-            &tx_info$.value, private_key, msg, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_msg_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CosmosSDKMsgRaw const &msg) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_msg_signed_tx(&tx_info$.value, private_key, msg, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the transaction signing payload (`SignDoc`)
 /// for `MsgSend` from the Cosmos SDK bank module
-::rust::Vec<::std::uint8_t> get_single_bank_send_signdoc(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::rust::Vec<::std::uint8_t> sender_pubkey, ::rust::String recipient_address,
-    ::std::uint64_t amount, ::rust::String denom) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> sender_pubkey$(
-        ::std::move(sender_pubkey));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_single_bank_send_signdoc(
-            &tx_info$.value, &sender_pubkey$.value, &recipient_address, amount,
-            &denom, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_single_bank_send_signdoc(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::rust::Vec<::std::uint8_t> sender_pubkey, ::rust::String recipient_address, ::std::uint64_t amount, ::rust::String denom) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> sender_pubkey$(::std::move(sender_pubkey));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_single_bank_send_signdoc(&tx_info$.value, &sender_pubkey$.value, &recipient_address, amount, &denom, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgSend` from the Cosmos SDK bank module
-::rust::Vec<::std::uint8_t> get_single_bank_send_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String recipient_address, ::std::uint64_t amount,
-    ::rust::String denom) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_single_bank_send_signed_tx(
-            &tx_info$.value, private_key, &recipient_address, amount, &denom,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_single_bank_send_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String recipient_address, ::std::uint64_t amount, ::rust::String denom) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_single_bank_send_signed_tx(&tx_info$.value, private_key, &recipient_address, amount, &denom, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::std::size_t Wallet::layout::size() noexcept {
-    return org$defi_wallet_core$cxxbridge1$Wallet$operator$sizeof();
+  return org$defi_wallet_core$cxxbridge1$Wallet$operator$sizeof();
 }
 
 ::std::size_t Wallet::layout::align() noexcept {
-    return org$defi_wallet_core$cxxbridge1$Wallet$operator$alignof();
+  return org$defi_wallet_core$cxxbridge1$Wallet$operator$alignof();
 }
 
-/// generates the HD wallet with a BIP39 backup phrase (English words) and
-/// password
+/// generates the HD wallet with a BIP39 backup phrase (English words) and password
 ///
-::rust::Box<::org::defi_wallet_core::Wallet>
-new_wallet(::rust::String password,
-           ::org::defi_wallet_core::MnemonicWordCount word_count) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
-    ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_wallet(
-        &password, word_count, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::Wallet> new_wallet(::rust::String password, ::org::defi_wallet_core::MnemonicWordCount word_count) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_wallet(&password, word_count, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Wallet::get_backup_mnemonic_phrase() const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Wallet$get_backup_mnemonic_phrase(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Wallet$get_backup_mnemonic_phrase(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// generate mnemonics
 ///
-::rust::String
-generate_mnemonics(::rust::String password,
-                   ::org::defi_wallet_core::MnemonicWordCount word_count) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$generate_mnemonics(
-            &password, word_count, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and
-/// password and save to secure storage
-::rust::Box<::org::defi_wallet_core::Wallet>
-restore_wallet_save_to_securestorage(::rust::String mnemonic,
-                                     ::rust::String password,
-                                     ::rust::String servicename,
-                                     ::rust::String username) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$restore_wallet_save_to_securestorage(
-            &mnemonic, &password, &servicename, &username, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and
-/// password from secure storage
-::rust::Box<::org::defi_wallet_core::Wallet>
-restore_wallet_load_from_securestorage(::rust::String servicename,
-                                       ::rust::String username) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$restore_wallet_load_from_securestorage(
-            &servicename, &username, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and
-/// password
+::rust::String generate_mnemonics(::rust::String password, ::org::defi_wallet_core::MnemonicWordCount word_count) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$generate_mnemonics(&password, word_count, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and password
+/// and save to secure storage
+::rust::Box<::org::defi_wallet_core::Wallet> restore_wallet_save_to_securestorage(::rust::String mnemonic, ::rust::String password, ::rust::String servicename, ::rust::String username) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$restore_wallet_save_to_securestorage(&mnemonic, &password, &servicename, &username, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and password
+/// from secure storage
+::rust::Box<::org::defi_wallet_core::Wallet> restore_wallet_load_from_securestorage(::rust::String servicename, ::rust::String username) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$restore_wallet_load_from_securestorage(&servicename, &username, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and password
 ///
-::rust::Box<::org::defi_wallet_core::Wallet>
-restore_wallet(::rust::String mnemonic, ::rust::String password) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$restore_wallet(&mnemonic, &password,
-                                                       &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::Wallet> restore_wallet(::rust::String mnemonic, ::rust::String password) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::Wallet>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$restore_wallet(&mnemonic, &password, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::rust::String
-Wallet::get_default_address(::org::defi_wallet_core::CoinType coin) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Wallet$get_default_address(
-            *this, coin, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::String Wallet::get_default_address(::org::defi_wallet_core::CoinType coin) const {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Wallet$get_default_address(*this, coin, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::rust::String Wallet::get_address(::org::defi_wallet_core::CoinType coin,
-                                   ::std::uint32_t index) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Wallet$get_address(*this, coin, index,
-                                                           &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::String Wallet::get_address(::org::defi_wallet_core::CoinType coin, ::std::uint32_t index) const {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Wallet$get_address(*this, coin, index, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Wallet::get_eth_address(::std::uint32_t index) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Wallet$get_eth_address(*this, index,
-                                                               &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Box<::org::defi_wallet_core::PrivateKey>
-Wallet::get_key(::rust::String derivation_path) const {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::PrivateKey>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$Wallet$get_key(*this, &derivation_path,
-                                                       &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Wallet$get_eth_address(*this, index, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Box<::org::defi_wallet_core::PrivateKey> Wallet::get_key(::rust::String derivation_path) const {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::PrivateKey>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$Wallet$get_key(*this, &derivation_path, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// generates a random private key
 ///
 ::rust::Box<::org::defi_wallet_core::PrivateKey> new_privatekey() noexcept {
-    return ::rust::Box<::org::defi_wallet_core::PrivateKey>::from_raw(
-        org$defi_wallet_core$cxxbridge1$new_privatekey());
+  return ::rust::Box<::org::defi_wallet_core::PrivateKey>::from_raw(org$defi_wallet_core$cxxbridge1$new_privatekey());
 }
 
 /// constructs private key from bytes
 ///
-::rust::Box<::org::defi_wallet_core::PrivateKey>
-new_privatekey_from_bytes(::rust::Vec<::std::uint8_t> bytes) {
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> bytes$(
-        ::std::move(bytes));
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::PrivateKey>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$new_privatekey_from_bytes(
-            &bytes$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::PrivateKey> new_privatekey_from_bytes(::rust::Vec<::std::uint8_t> bytes) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> bytes$(::std::move(bytes));
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::PrivateKey>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_privatekey_from_bytes(&bytes$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// constructs private key from hex string
 ///
-::rust::Box<::org::defi_wallet_core::PrivateKey>
-new_privatekey_from_hex(::rust::String hex) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::PrivateKey>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$new_privatekey_from_hex(&hex,
-                                                                &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::PrivateKey> new_privatekey_from_hex(::rust::String hex) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::PrivateKey>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_privatekey_from_hex(&hex, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgDelegate` from the Cosmos SDK staking module
-::rust::Vec<::std::uint8_t> get_staking_delegate_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_address, ::std::uint64_t amount,
-    ::rust::String denom, bool with_reward_withdrawal) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_staking_delegate_signed_tx(
-            &tx_info$.value, private_key, &validator_address, amount, &denom,
-            with_reward_withdrawal, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_staking_delegate_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_address, ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_staking_delegate_signed_tx(&tx_info$.value, private_key, &validator_address, amount, &denom, with_reward_withdrawal, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgBeginRedelegate` from the Cosmos SDK staking module
-::rust::Vec<::std::uint8_t> get_staking_redelegate_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_src_address, ::rust::String validator_dst_address,
-    ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_staking_redelegate_signed_tx(
-            &tx_info$.value, private_key, &validator_src_address,
-            &validator_dst_address, amount, &denom, with_reward_withdrawal,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_staking_redelegate_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_src_address, ::rust::String validator_dst_address, ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_staking_redelegate_signed_tx(&tx_info$.value, private_key, &validator_src_address, &validator_dst_address, amount, &denom, with_reward_withdrawal, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgUndelegate` from the Cosmos SDK staking module
-::rust::Vec<::std::uint8_t> get_staking_unbond_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_address, ::std::uint64_t amount,
-    ::rust::String denom, bool with_reward_withdrawal) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_staking_unbond_signed_tx(
-            &tx_info$.value, private_key, &validator_address, amount, &denom,
-            with_reward_withdrawal, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_staking_unbond_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_address, ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_staking_unbond_signed_tx(&tx_info$.value, private_key, &validator_address, amount, &denom, with_reward_withdrawal, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgSetWithdrawAddress` from the Cosmos SDK distributon module
-::rust::Vec<::std::uint8_t> get_distribution_set_withdraw_address_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String withdraw_address) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_distribution_set_withdraw_address_signed_tx(
-            &tx_info$.value, private_key, &withdraw_address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_distribution_set_withdraw_address_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String withdraw_address) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_distribution_set_withdraw_address_signed_tx(&tx_info$.value, private_key, &withdraw_address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgWithdrawDelegatorReward` from the Cosmos SDK distributon module
-::rust::Vec<::std::uint8_t> get_distribution_withdraw_reward_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_address) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_distribution_withdraw_reward_signed_tx(
-            &tx_info$.value, private_key, &validator_address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_distribution_withdraw_reward_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_address) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_distribution_withdraw_reward_signed_tx(&tx_info$.value, private_key, &validator_address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgTransfer` from the Cosmos SDK ibc module
-::rust::Vec<::std::uint8_t> get_ibc_transfer_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String receiver, ::rust::String source_port,
-    ::rust::String source_channel, ::rust::String denom, ::std::uint64_t token,
-    ::std::uint64_t revision_height, ::std::uint64_t revision_number,
-    ::std::uint64_t timeout_timestamp) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_ibc_transfer_signed_tx(
-            &tx_info$.value, private_key, &receiver, &source_port,
-            &source_channel, &denom, token, revision_height, revision_number,
-            timeout_timestamp, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_ibc_transfer_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String receiver, ::rust::String source_port, ::rust::String source_channel, ::rust::String denom, ::std::uint64_t token, ::std::uint64_t revision_height, ::std::uint64_t revision_number, ::std::uint64_t timeout_timestamp) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_ibc_transfer_signed_tx(&tx_info$.value, private_key, &receiver, &source_port, &source_channel, &denom, token, revision_height, revision_number, timeout_timestamp, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::std::size_t CppLoginInfo::layout::size() noexcept {
-    return org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$sizeof();
+  return org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$sizeof();
 }
 
 ::std::size_t CppLoginInfo::layout::align() noexcept {
-    return org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$alignof();
+  return org$defi_wallet_core$cxxbridge1$CppLoginInfo$operator$alignof();
 }
 
 /// Create Login Info by `msg`
 /// all information from the EIP-4361 plaintext message:
 /// https://eips.ethereum.org/EIPS/eip-4361
-::rust::Box<::org::defi_wallet_core::CppLoginInfo>
-new_logininfo(::rust::String msg) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::CppLoginInfo>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$new_logininfo(&msg, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::CppLoginInfo> new_logininfo(::rust::String msg) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::CppLoginInfo>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_logininfo(&msg, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::rust::Vec<::std::uint8_t> CppLoginInfo::sign_logininfo(
-    ::org::defi_wallet_core::PrivateKey const &private_key) const {
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$CppLoginInfo$sign_logininfo(
-            *this, private_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> CppLoginInfo::sign_logininfo(::org::defi_wallet_core::PrivateKey const &private_key) const {
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$CppLoginInfo$sign_logininfo(*this, private_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-void CppLoginInfo::verify_logininfo(
-    ::rust::Slice<::std::uint8_t const> signature) const {
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$CppLoginInfo$verify_logininfo(
-            *this, signature);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
+void CppLoginInfo::verify_logininfo(::rust::Slice<::std::uint8_t const> signature) const {
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$CppLoginInfo$verify_logininfo(*this, signature);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
 }
 
 /// create cronos tx info to sign
 ///
 ::org::defi_wallet_core::EthTxInfoRaw new_eth_tx_info() noexcept {
-    ::rust::MaybeUninit<::org::defi_wallet_core::EthTxInfoRaw> return$;
-    org$defi_wallet_core$cxxbridge1$new_eth_tx_info(&return$.value);
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::EthTxInfoRaw> return$;
+  org$defi_wallet_core$cxxbridge1$new_eth_tx_info(&return$.value);
+  return ::std::move(return$.value);
 }
 
 /// sign cronos tx with private key
 ///
-::rust::Vec<::std::uint8_t>
-build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info,
-                    ::rust::Str network,
-                    ::org::defi_wallet_core::PrivateKey const &secret_key) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::EthTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$build_eth_signed_tx(
-            &tx_info$.value, network, secret_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info, ::rust::Str network, ::org::defi_wallet_core::PrivateKey const &secret_key) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::EthTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$build_eth_signed_tx(&tx_info$.value, network, secret_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// sign cronos tx with private key in custom network
 ///
-::rust::Vec<::std::uint8_t>
-build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info,
-                    ::std::uint64_t chain_id, bool legacy,
-                    ::org::defi_wallet_core::PrivateKey const &secret_key) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::EthTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$build_custom_eth_signed_tx(
-            &tx_info$.value, chain_id, legacy, secret_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info, ::std::uint64_t chain_id, bool legacy, ::org::defi_wallet_core::PrivateKey const &secret_key) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::EthTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$build_custom_eth_signed_tx(&tx_info$.value, chain_id, legacy, secret_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// given the account address, it returns the amount of native token it owns
 ///
-::org::defi_wallet_core::U256 get_eth_balance(::rust::Str address,
-                                              ::rust::Str api_url) {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_eth_balance(address, api_url,
-                                                        &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::U256 get_eth_balance(::rust::Str address, ::rust::Str api_url) {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_eth_balance(address, api_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// Returns the corresponding account's nonce / number of transactions
 /// sent from it.
 ::rust::String get_eth_nonce(::rust::Str address, ::rust::Str api_url) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_eth_nonce(
-        address, api_url, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_eth_nonce(address, api_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String get_block_number_blocking(::rust::String api_url) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_block_number_blocking(
-            &api_url, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::String
-get_eth_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash,
-                                     ::rust::String api_url) {
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> tx_hash$(
-        ::std::move(tx_hash));
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_vec_blocking(
-            &tx_hash$.value, &api_url, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::String get_eth_transaction_receipt_blocking(::rust::String tx_hash,
-                                                    ::rust::String api_url) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_string_blocking(
-            &tx_hash, &api_url, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::String
-wait_for_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash,
-                                      ::rust::String api_url) {
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> tx_hash$(
-        ::std::move(tx_hash));
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_vec_blocking(
-            &tx_hash$.value, &api_url, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::String wait_for_transaction_receipt_blocking(::rust::String tx_hash,
-                                                     ::rust::String api_url) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_string_blocking(
-            &tx_hash, &api_url, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_block_number_blocking(&api_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String get_eth_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash, ::rust::String api_url) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> tx_hash$(::std::move(tx_hash));
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_vec_blocking(&tx_hash$.value, &api_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String get_eth_transaction_receipt_blocking(::rust::String tx_hash, ::rust::String api_url) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_eth_transaction_receipt_by_string_blocking(&tx_hash, &api_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String wait_for_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash, ::rust::String api_url) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> tx_hash$(::std::move(tx_hash));
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_vec_blocking(&tx_hash$.value, &api_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String wait_for_transaction_receipt_blocking(::rust::String tx_hash, ::rust::String api_url) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$wait_for_transaction_receipt_by_string_blocking(&tx_hash, &api_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// broadcast signed cronos tx
 ///
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-broadcast_eth_signed_raw_tx(::rust::Vec<::std::uint8_t> raw_tx,
-                            ::rust::Str web3api_url,
-                            ::std::uint64_t polling_interval_ms) {
-    ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> raw_tx$(
-        ::std::move(raw_tx));
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$broadcast_eth_signed_raw_tx(
-            &raw_tx$.value, web3api_url, polling_interval_ms, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::CronosTransactionReceiptRaw broadcast_eth_signed_raw_tx(::rust::Vec<::std::uint8_t> raw_tx, ::rust::Str web3api_url, ::std::uint64_t polling_interval_ms) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> raw_tx$(::std::move(raw_tx));
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$broadcast_eth_signed_raw_tx(&raw_tx$.value, web3api_url, polling_interval_ms, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// set cronos http-agent name
 ///
 void set_cronos_httpagent(::rust::Str agent) {
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$set_cronos_httpagent(agent);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$set_cronos_httpagent(agent);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
 }
 } // namespace defi_wallet_core
 } // namespace org
 
 extern "C" {
-::org::defi_wallet_core::Wallet *
-cxxbridge1$box$org$defi_wallet_core$Wallet$alloc() noexcept;
-void cxxbridge1$box$org$defi_wallet_core$Wallet$dealloc(
-    ::org::defi_wallet_core::Wallet *) noexcept;
-void cxxbridge1$box$org$defi_wallet_core$Wallet$drop(
-    ::rust::Box<::org::defi_wallet_core::Wallet> *ptr) noexcept;
-
-::org::defi_wallet_core::PrivateKey *
-cxxbridge1$box$org$defi_wallet_core$PrivateKey$alloc() noexcept;
-void cxxbridge1$box$org$defi_wallet_core$PrivateKey$dealloc(
-    ::org::defi_wallet_core::PrivateKey *) noexcept;
-void cxxbridge1$box$org$defi_wallet_core$PrivateKey$drop(
-    ::rust::Box<::org::defi_wallet_core::PrivateKey> *ptr) noexcept;
-
-::org::defi_wallet_core::CppLoginInfo *
-cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$alloc() noexcept;
-void cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$dealloc(
-    ::org::defi_wallet_core::CppLoginInfo *) noexcept;
-void cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$drop(
-    ::rust::Box<::org::defi_wallet_core::CppLoginInfo> *ptr) noexcept;
+::org::defi_wallet_core::Wallet *cxxbridge1$box$org$defi_wallet_core$Wallet$alloc() noexcept;
+void cxxbridge1$box$org$defi_wallet_core$Wallet$dealloc(::org::defi_wallet_core::Wallet *) noexcept;
+void cxxbridge1$box$org$defi_wallet_core$Wallet$drop(::rust::Box<::org::defi_wallet_core::Wallet> *ptr) noexcept;
+
+::org::defi_wallet_core::PrivateKey *cxxbridge1$box$org$defi_wallet_core$PrivateKey$alloc() noexcept;
+void cxxbridge1$box$org$defi_wallet_core$PrivateKey$dealloc(::org::defi_wallet_core::PrivateKey *) noexcept;
+void cxxbridge1$box$org$defi_wallet_core$PrivateKey$drop(::rust::Box<::org::defi_wallet_core::PrivateKey> *ptr) noexcept;
+
+::org::defi_wallet_core::CppLoginInfo *cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$alloc() noexcept;
+void cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$dealloc(::org::defi_wallet_core::CppLoginInfo *) noexcept;
+void cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$drop(::rust::Box<::org::defi_wallet_core::CppLoginInfo> *ptr) noexcept;
 } // extern "C"
 
 namespace rust {
 inline namespace cxxbridge1 {
 template <>
-::org::defi_wallet_core::Wallet *
-Box<::org::defi_wallet_core::Wallet>::allocation::alloc() noexcept {
-    return cxxbridge1$box$org$defi_wallet_core$Wallet$alloc();
+::org::defi_wallet_core::Wallet *Box<::org::defi_wallet_core::Wallet>::allocation::alloc() noexcept {
+  return cxxbridge1$box$org$defi_wallet_core$Wallet$alloc();
 }
 template <>
-void Box<::org::defi_wallet_core::Wallet>::allocation::dealloc(
-    ::org::defi_wallet_core::Wallet *ptr) noexcept {
-    cxxbridge1$box$org$defi_wallet_core$Wallet$dealloc(ptr);
+void Box<::org::defi_wallet_core::Wallet>::allocation::dealloc(::org::defi_wallet_core::Wallet *ptr) noexcept {
+  cxxbridge1$box$org$defi_wallet_core$Wallet$dealloc(ptr);
 }
-template <> void Box<::org::defi_wallet_core::Wallet>::drop() noexcept {
-    cxxbridge1$box$org$defi_wallet_core$Wallet$drop(this);
+template <>
+void Box<::org::defi_wallet_core::Wallet>::drop() noexcept {
+  cxxbridge1$box$org$defi_wallet_core$Wallet$drop(this);
 }
 template <>
-::org::defi_wallet_core::PrivateKey *
-Box<::org::defi_wallet_core::PrivateKey>::allocation::alloc() noexcept {
-    return cxxbridge1$box$org$defi_wallet_core$PrivateKey$alloc();
+::org::defi_wallet_core::PrivateKey *Box<::org::defi_wallet_core::PrivateKey>::allocation::alloc() noexcept {
+  return cxxbridge1$box$org$defi_wallet_core$PrivateKey$alloc();
 }
 template <>
-void Box<::org::defi_wallet_core::PrivateKey>::allocation::dealloc(
-    ::org::defi_wallet_core::PrivateKey *ptr) noexcept {
-    cxxbridge1$box$org$defi_wallet_core$PrivateKey$dealloc(ptr);
+void Box<::org::defi_wallet_core::PrivateKey>::allocation::dealloc(::org::defi_wallet_core::PrivateKey *ptr) noexcept {
+  cxxbridge1$box$org$defi_wallet_core$PrivateKey$dealloc(ptr);
 }
-template <> void Box<::org::defi_wallet_core::PrivateKey>::drop() noexcept {
-    cxxbridge1$box$org$defi_wallet_core$PrivateKey$drop(this);
+template <>
+void Box<::org::defi_wallet_core::PrivateKey>::drop() noexcept {
+  cxxbridge1$box$org$defi_wallet_core$PrivateKey$drop(this);
 }
 template <>
-::org::defi_wallet_core::CppLoginInfo *
-Box<::org::defi_wallet_core::CppLoginInfo>::allocation::alloc() noexcept {
-    return cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$alloc();
+::org::defi_wallet_core::CppLoginInfo *Box<::org::defi_wallet_core::CppLoginInfo>::allocation::alloc() noexcept {
+  return cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$alloc();
 }
 template <>
-void Box<::org::defi_wallet_core::CppLoginInfo>::allocation::dealloc(
-    ::org::defi_wallet_core::CppLoginInfo *ptr) noexcept {
-    cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$dealloc(ptr);
+void Box<::org::defi_wallet_core::CppLoginInfo>::allocation::dealloc(::org::defi_wallet_core::CppLoginInfo *ptr) noexcept {
+  cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$dealloc(ptr);
 }
-template <> void Box<::org::defi_wallet_core::CppLoginInfo>::drop() noexcept {
-    cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$drop(this);
+template <>
+void Box<::org::defi_wallet_core::CppLoginInfo>::drop() noexcept {
+  cxxbridge1$box$org$defi_wallet_core$CppLoginInfo$drop(this);
 }
 } // namespace cxxbridge1
 } // namespace rust
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.cc b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.cc
index f6156d30..4e82f53c 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.cc
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.cc
@@ -19,755 +19,822 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_STR
 #define CXXBRIDGE1_RUST_STR
 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;
-
-    const char *data() const noexcept;
-    std::size_t size() const noexcept;
-    std::size_t length() const noexcept;
-    bool empty() const noexcept;
-
-    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;
+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;
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  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
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -777,31 +844,31 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_ERROR
 #define CXXBRIDGE1_RUST_ERROR
 class Error final : public std::exception {
-  public:
-    Error(const Error &);
-    Error(Error &&) noexcept;
-    ~Error() noexcept override;
+public:
+  Error(const Error &);
+  Error(Error &&) noexcept;
+  ~Error() noexcept override;
 
-    Error &operator=(const Error &) &;
-    Error &operator=(Error &&) &noexcept;
+  Error &operator=(const Error &) &;
+  Error &operator=(Error &&) &noexcept;
 
-    const char *what() const noexcept override;
+  const char *what() const noexcept override;
 
-  private:
-    Error() noexcept = default;
-    friend impl<Error>;
-    const char *msg;
-    std::size_t len;
+private:
+  Error() noexcept = default;
+  friend impl<Error>;
+  const char *msg;
+  std::size_t len;
 };
 #endif // CXXBRIDGE1_RUST_ERROR
 
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -820,57 +887,69 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_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>
+struct make_void {
+  using type = void;
+};
 
-template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
 
 template <typename Void, template <typename...> class, typename...>
 struct detect : std::false_type {};
@@ -880,7 +959,8 @@ 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>
+using detect_IsRelocatable = typename T::IsRelocatable;
 
 template <typename T>
 struct get_IsRelocatable
@@ -899,231 +979,179 @@ struct IsRelocatable
 
 namespace repr {
 struct PtrLen final {
-    void *ptr;
-    ::std::size_t len;
+  void *ptr;
+  ::std::size_t len;
 };
 } // namespace repr
 
 namespace detail {
-template <typename T, typename = void *> struct operator_new {
-    void *operator()(::std::size_t sz) { return ::operator new(sz); }
+template <typename T, typename = void *>
+struct operator_new {
+  void *operator()(::std::size_t sz) { return ::operator new(sz); }
 };
 
 template <typename T>
 struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
-    void *operator()(::std::size_t sz) { return T::operator new(sz); }
+  void *operator()(::std::size_t sz) { return T::operator new(sz); }
 };
 } // namespace detail
 
-template <typename T> union MaybeUninit {
-    T value;
-    void *operator new(::std::size_t sz) {
-        return detail::operator_new<T>{}(sz);
-    }
-    MaybeUninit() {}
-    ~MaybeUninit() {}
+template <typename T>
+union MaybeUninit {
+  T value;
+  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
+  MaybeUninit() {}
+  ~MaybeUninit() {}
 };
 
 namespace {
-template <> class impl<Error> final {
-  public:
-    static Error error(repr::PtrLen repr) noexcept {
-        Error error;
-        error.msg = static_cast<char const *>(repr.ptr);
-        error.len = repr.len;
-        return error;
-    }
+template <>
+class impl<Error> final {
+public:
+  static Error error(repr::PtrLen repr) noexcept {
+    Error error;
+    error.msg = static_cast<char const *>(repr.ptr);
+    error.len = repr.len;
+    return error;
+  }
 };
 } // namespace
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct EthContract;
+  namespace defi_wallet_core {
+    struct EthContract;
+  }
 }
-} // namespace org
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthContract
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthContract
 struct EthContract final : public ::rust::Opaque {
-    ::rust::Vec<::std::uint8_t> encode(::rust::Str function_name,
-                                       ::rust::Str function_args);
-    ::rust::String call(::rust::Str function_name, ::rust::Str function_args);
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    send(::rust::Str function_name, ::rust::Str function_args);
-    ~EthContract() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ::rust::Vec<::std::uint8_t> encode(::rust::Str function_name, ::rust::Str function_args);
+  ::rust::String call(::rust::Str function_name, ::rust::Str function_args);
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw send(::rust::Str function_name, ::rust::Str function_args);
+  ~EthContract() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthContract
 } // namespace defi_wallet_core
 } // namespace org
 
-static_assert(::rust::IsRelocatable<
-                  ::org::defi_wallet_core::CronosTransactionReceiptRaw>::value,
-              "type org::defi_wallet_core::CronosTransactionReceiptRaw should "
-              "be trivially move constructible and trivially destructible in "
-              "C++ to be used as a return value of `send` in Rust");
+static_assert(
+    ::rust::IsRelocatable<::org::defi_wallet_core::CronosTransactionReceiptRaw>::value,
+    "type org::defi_wallet_core::CronosTransactionReceiptRaw should be trivially move constructible and trivially destructible in C++ to be used as a return value of `send` in Rust");
 
 namespace org {
 namespace defi_wallet_core {
 extern "C" {
-::std::size_t
-org$defi_wallet_core$cxxbridge1$EthContract$operator$sizeof() noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$EthContract$operator$alignof() noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_eth_contract(
-    ::rust::String *rpcserver, ::rust::String *contact_address,
-    ::rust::String *abi_json,
-    ::rust::Box<::org::defi_wallet_core::EthContract> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_signing_eth_contract(
-    ::rust::String *rpcserver, ::rust::String *contact_address,
-    ::rust::String *abi_json,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::std::uint64_t chainid,
-    ::rust::Box<::org::defi_wallet_core::EthContract> *return$) noexcept;
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$read_json(::rust::String *filepath,
-                                          ::rust::String *keyname,
-                                          ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$EthContract$encode(
-    ::org::defi_wallet_core::EthContract &self, ::rust::Str function_name,
-    ::rust::Str function_args, ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$EthContract$call(
-    ::org::defi_wallet_core::EthContract &self, ::rust::Str function_name,
-    ::rust::Str function_args, ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$EthContract$send(
-    ::org::defi_wallet_core::EthContract &self, ::rust::Str function_name,
-    ::rust::Str function_args,
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$EthContract$operator$sizeof() noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$EthContract$operator$alignof() noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_eth_contract(::rust::String *rpcserver, ::rust::String *contact_address, ::rust::String *abi_json, ::rust::Box<::org::defi_wallet_core::EthContract> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_signing_eth_contract(::rust::String *rpcserver, ::rust::String *contact_address, ::rust::String *abi_json, ::org::defi_wallet_core::PrivateKey const &private_key, ::std::uint64_t chainid, ::rust::Box<::org::defi_wallet_core::EthContract> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$read_json(::rust::String *filepath, ::rust::String *keyname, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$EthContract$encode(::org::defi_wallet_core::EthContract &self, ::rust::Str function_name, ::rust::Str function_args, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$EthContract$call(::org::defi_wallet_core::EthContract &self, ::rust::Str function_name, ::rust::Str function_args, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$EthContract$send(::org::defi_wallet_core::EthContract &self, ::rust::Str function_name, ::rust::Str function_args, ::org::defi_wallet_core::CronosTransactionReceiptRaw *return$) noexcept;
 } // extern "C"
 
 ::std::size_t EthContract::layout::size() noexcept {
-    return org$defi_wallet_core$cxxbridge1$EthContract$operator$sizeof();
+  return org$defi_wallet_core$cxxbridge1$EthContract$operator$sizeof();
 }
 
 ::std::size_t EthContract::layout::align() noexcept {
-    return org$defi_wallet_core$cxxbridge1$EthContract$operator$alignof();
-}
-
-::rust::Box<::org::defi_wallet_core::EthContract>
-new_eth_contract(::rust::String rpcserver, ::rust::String contact_address,
-                 ::rust::String abi_json) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::EthContract>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$new_eth_contract(
-            &rpcserver, &contact_address, &abi_json, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Box<::org::defi_wallet_core::EthContract>
-new_signing_eth_contract(::rust::String rpcserver,
-                         ::rust::String contact_address,
-                         ::rust::String abi_json,
-                         ::org::defi_wallet_core::PrivateKey const &private_key,
-                         ::std::uint64_t chainid) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::EthContract>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$new_signing_eth_contract(
-            &rpcserver, &contact_address, &abi_json, private_key, chainid,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  return org$defi_wallet_core$cxxbridge1$EthContract$operator$alignof();
 }
 
-::rust::String read_json(::rust::String filepath, ::rust::String keyname) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$read_json(
-        &filepath, &keyname, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::EthContract> new_eth_contract(::rust::String rpcserver, ::rust::String contact_address, ::rust::String abi_json) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::EthContract>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_eth_contract(&rpcserver, &contact_address, &abi_json, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::rust::Vec<::std::uint8_t> EthContract::encode(::rust::Str function_name,
-                                                ::rust::Str function_args) {
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$EthContract$encode(
-            *this, function_name, function_args, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::EthContract> new_signing_eth_contract(::rust::String rpcserver, ::rust::String contact_address, ::rust::String abi_json, ::org::defi_wallet_core::PrivateKey const &private_key, ::std::uint64_t chainid) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::EthContract>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_signing_eth_contract(&rpcserver, &contact_address, &abi_json, private_key, chainid, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::rust::String EthContract::call(::rust::Str function_name,
-                                 ::rust::Str function_args) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$EthContract$call(
-            *this, function_name, function_args, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-EthContract::send(::rust::Str function_name, ::rust::Str function_args) {
-    ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$EthContract$send(
-            *this, function_name, function_args, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::String read_json(::rust::String filepath, ::rust::String keyname) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$read_json(&filepath, &keyname, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> EthContract::encode(::rust::Str function_name, ::rust::Str function_args) {
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$EthContract$encode(*this, function_name, function_args, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String EthContract::call(::rust::Str function_name, ::rust::Str function_args) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$EthContract$call(*this, function_name, function_args, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::CronosTransactionReceiptRaw EthContract::send(::rust::Str function_name, ::rust::Str function_args) {
+  ::rust::MaybeUninit<::org::defi_wallet_core::CronosTransactionReceiptRaw> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$EthContract$send(*this, function_name, function_args, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 } // namespace defi_wallet_core
 } // namespace org
 
 extern "C" {
-::org::defi_wallet_core::EthContract *
-cxxbridge1$box$org$defi_wallet_core$EthContract$alloc() noexcept;
-void cxxbridge1$box$org$defi_wallet_core$EthContract$dealloc(
-    ::org::defi_wallet_core::EthContract *) noexcept;
-void cxxbridge1$box$org$defi_wallet_core$EthContract$drop(
-    ::rust::Box<::org::defi_wallet_core::EthContract> *ptr) noexcept;
+::org::defi_wallet_core::EthContract *cxxbridge1$box$org$defi_wallet_core$EthContract$alloc() noexcept;
+void cxxbridge1$box$org$defi_wallet_core$EthContract$dealloc(::org::defi_wallet_core::EthContract *) noexcept;
+void cxxbridge1$box$org$defi_wallet_core$EthContract$drop(::rust::Box<::org::defi_wallet_core::EthContract> *ptr) noexcept;
 } // extern "C"
 
 namespace rust {
 inline namespace cxxbridge1 {
 template <>
-::org::defi_wallet_core::EthContract *
-Box<::org::defi_wallet_core::EthContract>::allocation::alloc() noexcept {
-    return cxxbridge1$box$org$defi_wallet_core$EthContract$alloc();
+::org::defi_wallet_core::EthContract *Box<::org::defi_wallet_core::EthContract>::allocation::alloc() noexcept {
+  return cxxbridge1$box$org$defi_wallet_core$EthContract$alloc();
 }
 template <>
-void Box<::org::defi_wallet_core::EthContract>::allocation::dealloc(
-    ::org::defi_wallet_core::EthContract *ptr) noexcept {
-    cxxbridge1$box$org$defi_wallet_core$EthContract$dealloc(ptr);
+void Box<::org::defi_wallet_core::EthContract>::allocation::dealloc(::org::defi_wallet_core::EthContract *ptr) noexcept {
+  cxxbridge1$box$org$defi_wallet_core$EthContract$dealloc(ptr);
 }
-template <> void Box<::org::defi_wallet_core::EthContract>::drop() noexcept {
-    cxxbridge1$box$org$defi_wallet_core$EthContract$drop(this);
+template <>
+void Box<::org::defi_wallet_core::EthContract>::drop() noexcept {
+  cxxbridge1$box$org$defi_wallet_core$EthContract$drop(this);
 }
 } // namespace cxxbridge1
 } // namespace rust
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.h
index 750b9cd6..07b662d3 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/ethereum.rs.h
@@ -19,755 +19,822 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_STR
 #define CXXBRIDGE1_RUST_STR
 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;
-
-    const char *data() const noexcept;
-    std::size_t size() const noexcept;
-    std::size_t length() const noexcept;
-    bool empty() const noexcept;
-
-    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;
+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;
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  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
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -777,10 +844,10 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -799,90 +866,89 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct EthContract;
+  namespace defi_wallet_core {
+    struct EthContract;
+  }
 }
-} // namespace org
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthContract
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthContract
 struct EthContract final : public ::rust::Opaque {
-    ::rust::Vec<::std::uint8_t> encode(::rust::Str function_name,
-                                       ::rust::Str function_args);
-    ::rust::String call(::rust::Str function_name, ::rust::Str function_args);
-    ::org::defi_wallet_core::CronosTransactionReceiptRaw
-    send(::rust::Str function_name, ::rust::Str function_args);
-    ~EthContract() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ::rust::Vec<::std::uint8_t> encode(::rust::Str function_name, ::rust::Str function_args);
+  ::rust::String call(::rust::Str function_name, ::rust::Str function_args);
+  ::org::defi_wallet_core::CronosTransactionReceiptRaw send(::rust::Str function_name, ::rust::Str function_args);
+  ~EthContract() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthContract
 
-::rust::Box<::org::defi_wallet_core::EthContract>
-new_eth_contract(::rust::String rpcserver, ::rust::String contact_address,
-                 ::rust::String abi_json);
+::rust::Box<::org::defi_wallet_core::EthContract> new_eth_contract(::rust::String rpcserver, ::rust::String contact_address, ::rust::String abi_json);
 
-::rust::Box<::org::defi_wallet_core::EthContract>
-new_signing_eth_contract(::rust::String rpcserver,
-                         ::rust::String contact_address,
-                         ::rust::String abi_json,
-                         ::org::defi_wallet_core::PrivateKey const &private_key,
-                         ::std::uint64_t chainid);
+::rust::Box<::org::defi_wallet_core::EthContract> new_signing_eth_contract(::rust::String rpcserver, ::rust::String contact_address, ::rust::String abi_json, ::org::defi_wallet_core::PrivateKey const &private_key, ::std::uint64_t chainid);
 
 ::rust::String read_json(::rust::String filepath, ::rust::String keyname);
 } // namespace defi_wallet_core
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/lib.rs.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/lib.rs.h
index 907e64b8..26060839 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/lib.rs.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/lib.rs.h
@@ -19,755 +19,822 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_STR
 #define CXXBRIDGE1_RUST_STR
 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;
-
-    const char *data() const noexcept;
-    std::size_t size() const noexcept;
-    std::size_t length() const noexcept;
-    bool empty() const noexcept;
-
-    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;
+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;
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  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
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -777,10 +844,10 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -799,400 +866,372 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-enum class CoinType : ::std::uint8_t;
-enum class MnemonicWordCount : ::std::uint8_t;
-enum class EthAmount : ::std::uint8_t;
-struct EthTxInfoRaw;
-struct CosmosSDKTxInfoRaw;
-struct CosmosAccountInfoRaw;
-struct CosmosTransactionReceiptRaw;
-struct CronosTransactionReceiptRaw;
-struct PrivateKey;
-struct CosmosSDKMsgRaw;
-struct Wallet;
-struct CppLoginInfo;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    enum class CoinType : ::std::uint8_t;
+    enum class MnemonicWordCount : ::std::uint8_t;
+    enum class EthAmount : ::std::uint8_t;
+    struct EthTxInfoRaw;
+    struct CosmosSDKTxInfoRaw;
+    struct CosmosAccountInfoRaw;
+    struct CosmosTransactionReceiptRaw;
+    struct CronosTransactionReceiptRaw;
+    struct PrivateKey;
+    struct CosmosSDKMsgRaw;
+    struct Wallet;
+    struct CppLoginInfo;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_ENUM_org$defi_wallet_core$CoinType
 #define CXXBRIDGE1_ENUM_org$defi_wallet_core$CoinType
 enum class CoinType : ::std::uint8_t {
-    /// Crypto.org Chain mainnet
-    ///
-    CryptoOrgMainnet = 0,
-    /// Crypto.org Chain testnet
-    ///
-    CryptoOrgTestnet = 1,
-    /// Cronos mainnet beta
-    ///
-    CronosMainnet = 2,
-    /// Cosmos Hub mainnet
-    ///
-    CosmosHub = 3,
-    /// Ethereum
-    ///
-    Ethereum = 4,
+  /// Crypto.org Chain mainnet
+  ///
+  CryptoOrgMainnet = 0,
+  /// Crypto.org Chain testnet
+  ///
+  CryptoOrgTestnet = 1,
+  /// Cronos mainnet beta
+  ///
+  CronosMainnet = 2,
+  /// Cosmos Hub mainnet
+  ///
+  CosmosHub = 3,
+  /// Ethereum
+  ///
+  Ethereum = 4,
 };
 #endif // CXXBRIDGE1_ENUM_org$defi_wallet_core$CoinType
 
 #ifndef CXXBRIDGE1_ENUM_org$defi_wallet_core$MnemonicWordCount
 #define CXXBRIDGE1_ENUM_org$defi_wallet_core$MnemonicWordCount
 enum class MnemonicWordCount : ::std::uint8_t {
-    /// Word 12
-    ///
-    Twelve = 0,
-    /// Word 18
-    ///
-    Eighteen = 1,
-    /// Word 24
-    ///
-    TwentyFour = 2,
+  /// Word 12
+  ///
+  Twelve = 0,
+  /// Word 18
+  ///
+  Eighteen = 1,
+  /// Word 24
+  ///
+  TwentyFour = 2,
 };
 #endif // CXXBRIDGE1_ENUM_org$defi_wallet_core$MnemonicWordCount
 
 #ifndef CXXBRIDGE1_ENUM_org$defi_wallet_core$EthAmount
 #define CXXBRIDGE1_ENUM_org$defi_wallet_core$EthAmount
 enum class EthAmount : ::std::uint8_t {
-    /// 10^-18 ETH
-    ///
-    WeiDecimal = 0,
-    /// 10^-9 ETH
-    ///
-    GweiDecimal = 1,
-    EthDecimal = 2,
+  /// 10^-18 ETH
+  ///
+  WeiDecimal = 0,
+  /// 10^-9 ETH
+  ///
+  GweiDecimal = 1,
+  EthDecimal = 2,
 };
 #endif // CXXBRIDGE1_ENUM_org$defi_wallet_core$EthAmount
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthTxInfoRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthTxInfoRaw
 struct EthTxInfoRaw final {
-    ::rust::String to_address;
-    ::rust::String amount;
-    ::org::defi_wallet_core::EthAmount amount_unit;
-    ::rust::String nonce;
-    ::rust::String gas_limit;
-    ::rust::String gas_price;
-    ::org::defi_wallet_core::EthAmount gas_price_unit;
-    ::rust::Vec<::std::uint8_t> data;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_address;
+  ::rust::String amount;
+  ::org::defi_wallet_core::EthAmount amount_unit;
+  ::rust::String nonce;
+  ::rust::String gas_limit;
+  ::rust::String gas_price;
+  ::org::defi_wallet_core::EthAmount gas_price_unit;
+  ::rust::Vec<::std::uint8_t> data;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$EthTxInfoRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKTxInfoRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKTxInfoRaw
 struct CosmosSDKTxInfoRaw final {
-    /// global account number of the sender
-    ///
-    ::std::uint64_t account_number;
-    /// equivalent of "account nonce"
-    ///
-    ::std::uint64_t sequence_number;
-    /// the maximum gas limit
-    ///
-    ::std::uint64_t gas_limit;
-    /// the amount fee to be paid (gas_limit * gas_price)
-    ///
-    ::std::uint64_t fee_amount;
-    /// the fee's denomination
-    ///
-    ::rust::String fee_denom;
-    /// transaction timeout
-    ///
-    ::std::uint32_t timeout_height;
-    /// optional memo
-    ///
-    ::rust::String memo_note;
-    /// the network chain id
-    ///
-    ::rust::String chain_id;
-    /// bech32 human readable prefix
-    ///
-    ::rust::String bech32hrp;
-    /// the coin type to use
-    ///
-    ::std::uint32_t coin_type;
-
-    using IsRelocatable = ::std::true_type;
+  /// global account number of the sender
+  ///
+  ::std::uint64_t account_number;
+  /// equivalent of "account nonce"
+  ///
+  ::std::uint64_t sequence_number;
+  /// the maximum gas limit
+  ///
+  ::std::uint64_t gas_limit;
+  /// the amount fee to be paid (gas_limit * gas_price)
+  ///
+  ::std::uint64_t fee_amount;
+  /// the fee's denomination
+  ///
+  ::rust::String fee_denom;
+  /// transaction timeout
+  ///
+  ::std::uint32_t timeout_height;
+  /// optional memo
+  ///
+  ::rust::String memo_note;
+  /// the network chain id
+  ///
+  ::rust::String chain_id;
+  /// bech32 human readable prefix
+  ///
+  ::rust::String bech32hrp;
+  /// the coin type to use
+  ///
+  ::std::uint32_t coin_type;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKTxInfoRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosAccountInfoRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosAccountInfoRaw
 struct CosmosAccountInfoRaw final {
-    ::std::uint64_t account_number;
-    ::std::uint64_t sequence_number;
+  ::std::uint64_t account_number;
+  ::std::uint64_t sequence_number;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosAccountInfoRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosTransactionReceiptRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosTransactionReceiptRaw
 struct CosmosTransactionReceiptRaw final {
-    /// tendermint transaction hash in hexadecimal
-    ///
-    ::rust::String tx_hash_hex;
-    /// error code (0 if success)
-    ///
-    ::std::uint32_t code;
-    /// possible error log
-    ///
-    ::rust::String log;
-
-    using IsRelocatable = ::std::true_type;
+  /// tendermint transaction hash in hexadecimal
+  ///
+  ::rust::String tx_hash_hex;
+  /// error code (0 if success)
+  ///
+  ::std::uint32_t code;
+  /// possible error log
+  ///
+  ::rust::String log;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosTransactionReceiptRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CronosTransactionReceiptRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CronosTransactionReceiptRaw
 struct CronosTransactionReceiptRaw final {
-    ::rust::Vec<::std::uint8_t> transaction_hash;
-    ::rust::String transaction_index;
-    ::rust::Vec<::std::uint8_t> block_hash;
-    ::rust::String block_number;
-    ::rust::String cumulative_gas_used;
-    ::rust::String gas_used;
-    ::rust::String contract_address;
-    ::rust::Vec<::rust::String> logs;
-    /// Status: either 1 (success) or 0 (failure)
-    ///
-    ::rust::String status;
-    ::rust::Vec<::std::uint8_t> root;
-    ::rust::Vec<::std::uint8_t> logs_bloom;
-    ::rust::String transaction_type;
-    ::rust::String effective_gas_price;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::Vec<::std::uint8_t> transaction_hash;
+  ::rust::String transaction_index;
+  ::rust::Vec<::std::uint8_t> block_hash;
+  ::rust::String block_number;
+  ::rust::String cumulative_gas_used;
+  ::rust::String gas_used;
+  ::rust::String contract_address;
+  ::rust::Vec<::rust::String> logs;
+  /// Status: either 1 (success) or 0 (failure)
+  ///
+  ::rust::String status;
+  ::rust::Vec<::std::uint8_t> root;
+  ::rust::Vec<::std::uint8_t> logs_bloom;
+  ::rust::String transaction_type;
+  ::rust::String effective_gas_price;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CronosTransactionReceiptRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$PrivateKey
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$PrivateKey
 struct PrivateKey final : public ::rust::Opaque {
-    ~PrivateKey() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ~PrivateKey() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$PrivateKey
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKMsgRaw
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKMsgRaw
 struct CosmosSDKMsgRaw final : public ::rust::Opaque {
-    ~CosmosSDKMsgRaw() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ~CosmosSDKMsgRaw() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CosmosSDKMsgRaw
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Wallet
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Wallet
 struct Wallet final : public ::rust::Opaque {
-    /// get backup mnemonic phrase
-    ///
-    ::rust::String get_backup_mnemonic_phrase() const;
-
-    /// returns the default address of the wallet
-    ///
-    ::rust::String
-    get_default_address(::org::defi_wallet_core::CoinType coin) const;
-
-    /// returns the address from index in wallet
-    ///
-    ::rust::String get_address(::org::defi_wallet_core::CoinType coin,
-                               ::std::uint32_t index) const;
-
-    /// returns the ethereum address from index in wallet
-    ///
-    ::rust::String get_eth_address(::std::uint32_t index) const;
-
-    /// return the secret key for a given derivation path
-    ///
-    ::rust::Box<::org::defi_wallet_core::PrivateKey>
-    get_key(::rust::String derivation_path) const;
-
-    ~Wallet() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// get backup mnemonic phrase
+  ///
+  ::rust::String get_backup_mnemonic_phrase() const;
+
+  /// returns the default address of the wallet
+  ///
+  ::rust::String get_default_address(::org::defi_wallet_core::CoinType coin) const;
+
+  /// returns the address from index in wallet
+  ///
+  ::rust::String get_address(::org::defi_wallet_core::CoinType coin, ::std::uint32_t index) const;
+
+  /// returns the ethereum address from index in wallet
+  ///
+  ::rust::String get_eth_address(::std::uint32_t index) const;
+
+  /// return the secret key for a given derivation path
+  ///
+  ::rust::Box<::org::defi_wallet_core::PrivateKey> get_key(::rust::String derivation_path) const;
+
+  ~Wallet() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Wallet
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$CppLoginInfo
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$CppLoginInfo
 struct CppLoginInfo final : public ::rust::Opaque {
-    /// Sign Login Info
-    /// constructs the plaintext message and signs it according to EIP-191
-    /// (as per EIP-4361). The returned vector is a serialized recoverable
-    /// signature (as used in Ethereum).
-    ::rust::Vec<::std::uint8_t> sign_logininfo(
-        ::org::defi_wallet_core::PrivateKey const &private_key) const;
-
-    /// Verify Login Info
-    /// It verified the signature matches + also verifies the content of the
-    /// message:
-    /// - address in the message matches the address recovered from the
-    /// signature
-    /// - the time is valid
-    /// ...
-    /// NOTE: the server may still need to do extra verifications according to
-    /// its needs (e.g. verify chain-id, nonce, uri + possibly fetch additional
-    /// data associated with the given Ethereum address, such as
-    /// ERC-20/ERC-721/ERC-1155 asset ownership)
-    void verify_logininfo(::rust::Slice<::std::uint8_t const> signature) const;
-
-    ~CppLoginInfo() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// Sign Login Info
+  /// constructs the plaintext message and signs it according to EIP-191
+  /// (as per EIP-4361). The returned vector is a serialized recoverable signature
+  /// (as used in Ethereum).
+  ::rust::Vec<::std::uint8_t> sign_logininfo(::org::defi_wallet_core::PrivateKey const &private_key) const;
+
+  /// Verify Login Info
+  /// It verified the signature matches + also verifies the content of the message:
+  /// - address in the message matches the address recovered from the signature
+  /// - the time is valid
+  /// ...
+  /// NOTE: the server may still need to do extra verifications according to its needs
+  /// (e.g. verify chain-id, nonce, uri + possibly fetch additional data associated
+  /// with the given Ethereum address, such as ERC-20/ERC-721/ERC-1155 asset ownership)
+  void verify_logininfo(::rust::Slice<::std::uint8_t const> signature) const;
+
+  ~CppLoginInfo() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$CppLoginInfo
 
 /// query account details from cosmos address
 ///
-::rust::String query_account_details(::rust::String api_url,
-                                     ::rust::String address);
+::rust::String query_account_details(::rust::String api_url, ::rust::String address);
 
 /// query account details info from cosmos address
 ///
-::org::defi_wallet_core::CosmosAccountInfoRaw
-query_account_details_info(::rust::String api_url, ::rust::String address);
+::org::defi_wallet_core::CosmosAccountInfoRaw query_account_details_info(::rust::String api_url, ::rust::String address);
 
 /// broadcast the cosmos transaction
 ///
-::org::defi_wallet_core::CosmosTransactionReceiptRaw
-broadcast_tx(::rust::String tendermint_rpc_url,
-             ::rust::Vec<::std::uint8_t> raw_signed_tx);
+::org::defi_wallet_core::CosmosTransactionReceiptRaw broadcast_tx(::rust::String tendermint_rpc_url, ::rust::Vec<::std::uint8_t> raw_signed_tx);
 
 /// query account balance from cosmos address and denom name
 ///
-::rust::String query_account_balance(::rust::String grpc_url,
-                                     ::rust::String address,
-                                     ::rust::String denom);
+::rust::String query_account_balance(::rust::String grpc_url, ::rust::String address, ::rust::String denom);
 
 /// creates the signed transaction for cosmos
 ///
-::rust::Vec<::std::uint8_t>
-get_msg_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                  ::org::defi_wallet_core::PrivateKey const &private_key,
-                  ::org::defi_wallet_core::CosmosSDKMsgRaw const &msg);
+::rust::Vec<::std::uint8_t> get_msg_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::org::defi_wallet_core::CosmosSDKMsgRaw const &msg);
 
 /// creates the transaction signing payload (`SignDoc`)
 /// for `MsgSend` from the Cosmos SDK bank module
-::rust::Vec<::std::uint8_t> get_single_bank_send_signdoc(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::rust::Vec<::std::uint8_t> sender_pubkey, ::rust::String recipient_address,
-    ::std::uint64_t amount, ::rust::String denom);
+::rust::Vec<::std::uint8_t> get_single_bank_send_signdoc(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::rust::Vec<::std::uint8_t> sender_pubkey, ::rust::String recipient_address, ::std::uint64_t amount, ::rust::String denom);
 
 /// creates the signed transaction
 /// for `MsgSend` from the Cosmos SDK bank module
-::rust::Vec<::std::uint8_t> get_single_bank_send_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String recipient_address, ::std::uint64_t amount,
-    ::rust::String denom);
-
-/// generates the HD wallet with a BIP39 backup phrase (English words) and
-/// password
+::rust::Vec<::std::uint8_t> get_single_bank_send_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String recipient_address, ::std::uint64_t amount, ::rust::String denom);
+
+/// generates the HD wallet with a BIP39 backup phrase (English words) and password
 ///
-::rust::Box<::org::defi_wallet_core::Wallet>
-new_wallet(::rust::String password,
-           ::org::defi_wallet_core::MnemonicWordCount word_count);
+::rust::Box<::org::defi_wallet_core::Wallet> new_wallet(::rust::String password, ::org::defi_wallet_core::MnemonicWordCount word_count);
 
 /// generate mnemonics
 ///
-::rust::String
-generate_mnemonics(::rust::String password,
-                   ::org::defi_wallet_core::MnemonicWordCount word_count);
-
-/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and
-/// password and save to secure storage
-::rust::Box<::org::defi_wallet_core::Wallet>
-restore_wallet_save_to_securestorage(::rust::String mnemonic,
-                                     ::rust::String password,
-                                     ::rust::String servicename,
-                                     ::rust::String username);
-
-/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and
-/// password from secure storage
-::rust::Box<::org::defi_wallet_core::Wallet>
-restore_wallet_load_from_securestorage(::rust::String servicename,
-                                       ::rust::String username);
-
-/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and
-/// password
+::rust::String generate_mnemonics(::rust::String password, ::org::defi_wallet_core::MnemonicWordCount word_count);
+
+/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and password
+/// and save to secure storage
+::rust::Box<::org::defi_wallet_core::Wallet> restore_wallet_save_to_securestorage(::rust::String mnemonic, ::rust::String password, ::rust::String servicename, ::rust::String username);
+
+/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and password
+/// from secure storage
+::rust::Box<::org::defi_wallet_core::Wallet> restore_wallet_load_from_securestorage(::rust::String servicename, ::rust::String username);
+
+/// recovers/imports HD wallet from a BIP39 backup phrase (English words) and password
 ///
-::rust::Box<::org::defi_wallet_core::Wallet>
-restore_wallet(::rust::String mnemonic, ::rust::String password);
+::rust::Box<::org::defi_wallet_core::Wallet> restore_wallet(::rust::String mnemonic, ::rust::String password);
 
 /// generates a random private key
 ///
@@ -1200,67 +1239,40 @@ ::rust::Box<::org::defi_wallet_core::PrivateKey> new_privatekey() noexcept;
 
 /// constructs private key from bytes
 ///
-::rust::Box<::org::defi_wallet_core::PrivateKey>
-new_privatekey_from_bytes(::rust::Vec<::std::uint8_t> bytes);
+::rust::Box<::org::defi_wallet_core::PrivateKey> new_privatekey_from_bytes(::rust::Vec<::std::uint8_t> bytes);
 
 /// constructs private key from hex string
 ///
-::rust::Box<::org::defi_wallet_core::PrivateKey>
-new_privatekey_from_hex(::rust::String hex);
+::rust::Box<::org::defi_wallet_core::PrivateKey> new_privatekey_from_hex(::rust::String hex);
 
 /// creates the signed transaction
 /// for `MsgDelegate` from the Cosmos SDK staking module
-::rust::Vec<::std::uint8_t> get_staking_delegate_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_address, ::std::uint64_t amount,
-    ::rust::String denom, bool with_reward_withdrawal);
+::rust::Vec<::std::uint8_t> get_staking_delegate_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_address, ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal);
 
 /// creates the signed transaction
 /// for `MsgBeginRedelegate` from the Cosmos SDK staking module
-::rust::Vec<::std::uint8_t> get_staking_redelegate_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_src_address, ::rust::String validator_dst_address,
-    ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal);
+::rust::Vec<::std::uint8_t> get_staking_redelegate_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_src_address, ::rust::String validator_dst_address, ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal);
 
 /// creates the signed transaction
 /// for `MsgUndelegate` from the Cosmos SDK staking module
-::rust::Vec<::std::uint8_t> get_staking_unbond_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_address, ::std::uint64_t amount,
-    ::rust::String denom, bool with_reward_withdrawal);
+::rust::Vec<::std::uint8_t> get_staking_unbond_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_address, ::std::uint64_t amount, ::rust::String denom, bool with_reward_withdrawal);
 
 /// creates the signed transaction
 /// for `MsgSetWithdrawAddress` from the Cosmos SDK distributon module
-::rust::Vec<::std::uint8_t> get_distribution_set_withdraw_address_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String withdraw_address);
+::rust::Vec<::std::uint8_t> get_distribution_set_withdraw_address_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String withdraw_address);
 
 /// creates the signed transaction
 /// for `MsgWithdrawDelegatorReward` from the Cosmos SDK distributon module
-::rust::Vec<::std::uint8_t> get_distribution_withdraw_reward_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String validator_address);
+::rust::Vec<::std::uint8_t> get_distribution_withdraw_reward_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String validator_address);
 
 /// creates the signed transaction
 /// for `MsgTransfer` from the Cosmos SDK ibc module
-::rust::Vec<::std::uint8_t> get_ibc_transfer_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key,
-    ::rust::String receiver, ::rust::String source_port,
-    ::rust::String source_channel, ::rust::String denom, ::std::uint64_t token,
-    ::std::uint64_t revision_height, ::std::uint64_t revision_number,
-    ::std::uint64_t timeout_timestamp);
+::rust::Vec<::std::uint8_t> get_ibc_transfer_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String receiver, ::rust::String source_port, ::rust::String source_channel, ::rust::String denom, ::std::uint64_t token, ::std::uint64_t revision_height, ::std::uint64_t revision_number, ::std::uint64_t timeout_timestamp);
 
 /// Create Login Info by `msg`
 /// all information from the EIP-4361 plaintext message:
 /// https://eips.ethereum.org/EIPS/eip-4361
-::rust::Box<::org::defi_wallet_core::CppLoginInfo>
-new_logininfo(::rust::String msg);
+::rust::Box<::org::defi_wallet_core::CppLoginInfo> new_logininfo(::rust::String msg);
 
 /// create cronos tx info to sign
 ///
@@ -1268,22 +1280,15 @@ ::org::defi_wallet_core::EthTxInfoRaw new_eth_tx_info() noexcept;
 
 /// sign cronos tx with private key
 ///
-::rust::Vec<::std::uint8_t>
-build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info,
-                    ::rust::Str network,
-                    ::org::defi_wallet_core::PrivateKey const &secret_key);
+::rust::Vec<::std::uint8_t> build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info, ::rust::Str network, ::org::defi_wallet_core::PrivateKey const &secret_key);
 
 /// sign cronos tx with private key in custom network
 ///
-::rust::Vec<::std::uint8_t>
-build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info,
-                    ::std::uint64_t chain_id, bool legacy,
-                    ::org::defi_wallet_core::PrivateKey const &secret_key);
+::rust::Vec<::std::uint8_t> build_eth_signed_tx(::org::defi_wallet_core::EthTxInfoRaw tx_info, ::std::uint64_t chain_id, bool legacy, ::org::defi_wallet_core::PrivateKey const &secret_key);
 
 /// given the account address, it returns the amount of native token it owns
 ///
-::org::defi_wallet_core::U256 get_eth_balance(::rust::Str address,
-                                              ::rust::Str api_url);
+::org::defi_wallet_core::U256 get_eth_balance(::rust::Str address, ::rust::Str api_url);
 
 /// Returns the corresponding account's nonce / number of transactions
 /// sent from it.
@@ -1291,26 +1296,17 @@ ::rust::String get_eth_nonce(::rust::Str address, ::rust::Str api_url);
 
 ::rust::String get_block_number_blocking(::rust::String api_url);
 
-::rust::String
-get_eth_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash,
-                                     ::rust::String api_url);
+::rust::String get_eth_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash, ::rust::String api_url);
 
-::rust::String get_eth_transaction_receipt_blocking(::rust::String tx_hash,
-                                                    ::rust::String api_url);
+::rust::String get_eth_transaction_receipt_blocking(::rust::String tx_hash, ::rust::String api_url);
 
-::rust::String
-wait_for_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash,
-                                      ::rust::String api_url);
+::rust::String wait_for_transaction_receipt_blocking(::rust::Vec<::std::uint8_t> tx_hash, ::rust::String api_url);
 
-::rust::String wait_for_transaction_receipt_blocking(::rust::String tx_hash,
-                                                     ::rust::String api_url);
+::rust::String wait_for_transaction_receipt_blocking(::rust::String tx_hash, ::rust::String api_url);
 
 /// broadcast signed cronos tx
 ///
-::org::defi_wallet_core::CronosTransactionReceiptRaw
-broadcast_eth_signed_raw_tx(::rust::Vec<::std::uint8_t> raw_tx,
-                            ::rust::Str web3api_url,
-                            ::std::uint64_t polling_interval_ms);
+::org::defi_wallet_core::CronosTransactionReceiptRaw broadcast_eth_signed_raw_tx(::rust::Vec<::std::uint8_t> raw_tx, ::rust::Str web3api_url, ::std::uint64_t polling_interval_ms);
 
 /// set cronos http-agent name
 ///
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.cc b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.cc
index 00267d3f..e4af640a 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.cc
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.cc
@@ -20,708 +20,775 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_SLICE
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -731,31 +798,31 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_ERROR
 #define CXXBRIDGE1_RUST_ERROR
 class Error final : public std::exception {
-  public:
-    Error(const Error &);
-    Error(Error &&) noexcept;
-    ~Error() noexcept override;
+public:
+  Error(const Error &);
+  Error(Error &&) noexcept;
+  ~Error() noexcept override;
 
-    Error &operator=(const Error &) &;
-    Error &operator=(Error &&) &noexcept;
+  Error &operator=(const Error &) &;
+  Error &operator=(Error &&) &noexcept;
 
-    const char *what() const noexcept override;
+  const char *what() const noexcept override;
 
-  private:
-    Error() noexcept = default;
-    friend impl<Error>;
-    const char *msg;
-    std::size_t len;
+private:
+  Error() noexcept = default;
+  friend impl<Error>;
+  const char *msg;
+  std::size_t len;
 };
 #endif // CXXBRIDGE1_RUST_ERROR
 
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -774,57 +841,69 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_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>
+struct make_void {
+  using type = void;
+};
 
-template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
 
 template <typename Void, template <typename...> class, typename...>
 struct detect : std::false_type {};
@@ -834,7 +913,8 @@ 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>
+using detect_IsRelocatable = typename T::IsRelocatable;
 
 template <typename T>
 struct get_IsRelocatable
@@ -853,171 +933,166 @@ struct IsRelocatable
 
 namespace repr {
 struct PtrLen final {
-    void *ptr;
-    ::std::size_t len;
+  void *ptr;
+  ::std::size_t len;
 };
 } // namespace repr
 
 namespace detail {
-template <typename T, typename = void *> struct operator_new {
-    void *operator()(::std::size_t sz) { return ::operator new(sz); }
+template <typename T, typename = void *>
+struct operator_new {
+  void *operator()(::std::size_t sz) { return ::operator new(sz); }
 };
 
 template <typename T>
 struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
-    void *operator()(::std::size_t sz) { return T::operator new(sz); }
+  void *operator()(::std::size_t sz) { return T::operator new(sz); }
 };
 } // namespace detail
 
-template <typename T> union ManuallyDrop {
-    T value;
-    ManuallyDrop(T &&value) : value(::std::move(value)) {}
-    ~ManuallyDrop() {}
+template <typename T>
+union ManuallyDrop {
+  T value;
+  ManuallyDrop(T &&value) : value(::std::move(value)) {}
+  ~ManuallyDrop() {}
 };
 
-template <typename T> union MaybeUninit {
-    T value;
-    void *operator new(::std::size_t sz) {
-        return detail::operator_new<T>{}(sz);
-    }
-    MaybeUninit() {}
-    ~MaybeUninit() {}
+template <typename T>
+union MaybeUninit {
+  T value;
+  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
+  MaybeUninit() {}
+  ~MaybeUninit() {}
 };
 
 namespace {
-template <> class impl<Error> final {
-  public:
-    static Error error(repr::PtrLen repr) noexcept {
-        Error error;
-        error.msg = static_cast<char const *>(repr.ptr);
-        error.len = repr.len;
-        return error;
-    }
+template <>
+class impl<Error> final {
+public:
+  static Error error(repr::PtrLen repr) noexcept {
+    Error error;
+    error.msg = static_cast<char const *>(repr.ptr);
+    error.len = repr.len;
+    return error;
+  }
 };
 } // namespace
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct Denom;
-struct BaseNft;
-struct IdCollection;
-struct Owner;
-struct Collection;
-using Pagination = ::org::defi_wallet_core::Pagination;
-struct GrpcClient;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    struct Denom;
+    struct BaseNft;
+    struct IdCollection;
+    struct Owner;
+    struct Collection;
+    using Pagination = ::org::defi_wallet_core::Pagination;
+    struct GrpcClient;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Denom
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Denom
 struct Denom final {
-    ::rust::String id;
-    ::rust::String name;
-    ::rust::String schema;
-    ::rust::String creator;
+  ::rust::String id;
+  ::rust::String name;
+  ::rust::String schema;
+  ::rust::String creator;
 
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Denom
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$BaseNft
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$BaseNft
 struct BaseNft final {
-    ::rust::String id;
-    ::rust::String name;
-    ::rust::String uri;
-    ::rust::String data;
-    ::rust::String owner;
-
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String id;
+  ::rust::String name;
+  ::rust::String uri;
+  ::rust::String data;
+  ::rust::String owner;
+
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$BaseNft
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$IdCollection
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$IdCollection
 struct IdCollection final {
-    ::rust::String denom_id;
-    ::rust::Vec<::rust::String> token_ids;
+  ::rust::String denom_id;
+  ::rust::Vec<::rust::String> token_ids;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$IdCollection
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Owner
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Owner
 struct Owner final {
-    ::rust::String address;
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> id_collections;
+  ::rust::String address;
+  ::rust::Vec<::org::defi_wallet_core::IdCollection> id_collections;
 
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Owner
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Collection
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Collection
 struct Collection final {
-    bool denom_option;
-    ::org::defi_wallet_core::Denom denom_value;
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> nfts;
+  bool denom_option;
+  ::org::defi_wallet_core::Denom denom_value;
+  ::rust::Vec<::org::defi_wallet_core::BaseNft> nfts;
 
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Collection
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$GrpcClient
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$GrpcClient
 struct GrpcClient final : public ::rust::Opaque {
-    /// Supply queries the total supply of a given denom or owner
-    ///
-    ::std::uint64_t supply(::rust::String denom_id, ::rust::String owner) const;
-
-    /// Owner queries the NFTs of the specified owner
-    ///
-    ::org::defi_wallet_core::Owner
-    owner(::rust::String denom_id, ::rust::String owner,
-          ::org::defi_wallet_core::Pagination const &pagination) const;
-
-    /// Collection queries the NFTs of the specified denom
-    ///
-    ::org::defi_wallet_core::Collection
-    collection(::rust::String denom_id,
-               ::org::defi_wallet_core::Pagination const &pagination) const;
-
-    /// Denom queries the definition of a given denom
-    ///
-    ::org::defi_wallet_core::Denom denom(::rust::String denom_id) const;
-
-    /// DenomByName queries the definition of a given denom by name
-    ///
-    ::org::defi_wallet_core::Denom
-    denom_by_name(::rust::String denom_name) const;
-
-    /// Denoms queries all the denoms
-    ///
-    ::rust::Vec<::org::defi_wallet_core::Denom>
-    denoms(::org::defi_wallet_core::Pagination const &pagination) const;
-
-    /// NFT queries the NFT for the given denom and token ID
-    ///
-    ::org::defi_wallet_core::BaseNft nft(::rust::String denom_id,
-                                         ::rust::String token_id) const;
-
-    ~GrpcClient() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// Supply queries the total supply of a given denom or owner
+  ///
+  ::std::uint64_t supply(::rust::String denom_id, ::rust::String owner) const;
+
+  /// Owner queries the NFTs of the specified owner
+  ///
+  ::org::defi_wallet_core::Owner owner(::rust::String denom_id, ::rust::String owner, ::org::defi_wallet_core::Pagination const &pagination) const;
+
+  /// Collection queries the NFTs of the specified denom
+  ///
+  ::org::defi_wallet_core::Collection collection(::rust::String denom_id, ::org::defi_wallet_core::Pagination const &pagination) const;
+
+  /// Denom queries the definition of a given denom
+  ///
+  ::org::defi_wallet_core::Denom denom(::rust::String denom_id) const;
+
+  /// DenomByName queries the definition of a given denom by name
+  ///
+  ::org::defi_wallet_core::Denom denom_by_name(::rust::String denom_name) const;
+
+  /// Denoms queries all the denoms
+  ///
+  ::rust::Vec<::org::defi_wallet_core::Denom> denoms(::org::defi_wallet_core::Pagination const &pagination) const;
+
+  /// NFT queries the NFT for the given denom and token ID
+  ///
+  ::org::defi_wallet_core::BaseNft nft(::rust::String denom_id, ::rust::String token_id) const;
+
+  ~GrpcClient() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$GrpcClient
 } // namespace defi_wallet_core
@@ -1025,570 +1100,388 @@ struct GrpcClient final : public ::rust::Opaque {
 
 static_assert(
     ::rust::IsRelocatable<::org::defi_wallet_core::CosmosSDKTxInfoRaw>::value,
-    "type org::defi_wallet_core::CosmosSDKTxInfoRaw should be trivially move "
-    "constructible and trivially destructible in C++ to be used as an argument "
-    "of `get_nft_issue_denom_signed_tx`, `get_nft_mint_signed_tx`, "
-    "`get_nft_edit_signed_tx` in Rust");
+    "type org::defi_wallet_core::CosmosSDKTxInfoRaw should be trivially move constructible and trivially destructible in C++ to be used as an argument of `get_nft_issue_denom_signed_tx`, `get_nft_mint_signed_tx`, `get_nft_edit_signed_tx` in Rust");
 
 namespace org {
 namespace defi_wallet_core {
 extern "C" {
-bool org$defi_wallet_core$cxxbridge1$Pagination$get_enable(
-    ::org::defi_wallet_core::Pagination const &self) noexcept {
-    bool (::org::defi_wallet_core::Pagination::*get_enable$)() const =
-        &::org::defi_wallet_core::Pagination::get_enable;
-    return (self.*get_enable$)();
-}
-
-void org$defi_wallet_core$cxxbridge1$Pagination$get_key(
-    ::org::defi_wallet_core::Pagination const &self,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept {
-    ::rust::Vec<::std::uint8_t> (
-        ::org::defi_wallet_core::Pagination::*get_key$)() const =
-        &::org::defi_wallet_core::Pagination::get_key;
-    new (return$)::rust::Vec<::std::uint8_t>((self.*get_key$)());
-}
-
-::std::uint64_t org$defi_wallet_core$cxxbridge1$Pagination$get_offset(
-    ::org::defi_wallet_core::Pagination const &self) noexcept {
-    ::std::uint64_t (::org::defi_wallet_core::Pagination::*get_offset$)()
-        const = &::org::defi_wallet_core::Pagination::get_offset;
-    return (self.*get_offset$)();
-}
-
-::std::uint64_t org$defi_wallet_core$cxxbridge1$Pagination$get_limit(
-    ::org::defi_wallet_core::Pagination const &self) noexcept {
-    ::std::uint64_t (::org::defi_wallet_core::Pagination::*get_limit$)() const =
-        &::org::defi_wallet_core::Pagination::get_limit;
-    return (self.*get_limit$)();
-}
-
-bool org$defi_wallet_core$cxxbridge1$Pagination$get_count_total(
-    ::org::defi_wallet_core::Pagination const &self) noexcept {
-    bool (::org::defi_wallet_core::Pagination::*get_count_total$)() const =
-        &::org::defi_wallet_core::Pagination::get_count_total;
-    return (self.*get_count_total$)();
-}
-
-bool org$defi_wallet_core$cxxbridge1$Pagination$get_reverse(
-    ::org::defi_wallet_core::Pagination const &self) noexcept {
-    bool (::org::defi_wallet_core::Pagination::*get_reverse$)() const =
-        &::org::defi_wallet_core::Pagination::get_reverse;
-    return (self.*get_reverse$)();
-}
-
-::rust::repr::PtrLen
-org$defi_wallet_core$cxxbridge1$get_nft_issue_denom_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id,
-    ::rust::String *name, ::rust::String *schema,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_mint_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id,
-    ::rust::String *denom_id, ::rust::String *name, ::rust::String *uri,
-    ::rust::String *data, ::rust::String *recipient,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_edit_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id,
-    ::rust::String *denom_id, ::rust::String *name, ::rust::String *uri,
-    ::rust::String *data, ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_transfer_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id,
-    ::rust::String *denom_id, ::rust::String *recipient,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_burn_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id,
-    ::rust::String *denom_id, ::rust::Vec<::std::uint8_t> *return$) noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$GrpcClient$operator$sizeof() noexcept;
-::std::size_t
-org$defi_wallet_core$cxxbridge1$GrpcClient$operator$alignof() noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_grpc_client(
-    ::rust::String *grpc_url,
-    ::rust::Box<::org::defi_wallet_core::GrpcClient> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$supply(
-    ::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id,
-    ::rust::String *owner, ::std::uint64_t *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$owner(
-    ::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id,
-    ::rust::String *owner,
-    ::org::defi_wallet_core::Pagination const &pagination,
-    ::org::defi_wallet_core::Owner *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$collection(
-    ::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id,
-    ::org::defi_wallet_core::Pagination const &pagination,
-    ::org::defi_wallet_core::Collection *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$denom(
-    ::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id,
-    ::org::defi_wallet_core::Denom *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$denom_by_name(
-    ::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_name,
-    ::org::defi_wallet_core::Denom *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$denoms(
-    ::org::defi_wallet_core::GrpcClient const &self,
-    ::org::defi_wallet_core::Pagination const &pagination,
-    ::rust::Vec<::org::defi_wallet_core::Denom> *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$nft(
-    ::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id,
-    ::rust::String *token_id,
-    ::org::defi_wallet_core::BaseNft *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Owner$to_string(
-    ::org::defi_wallet_core::Owner const &self,
-    ::rust::String *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Collection$to_string(
-    ::org::defi_wallet_core::Collection const &self,
-    ::rust::String *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$Denom$to_string(
-    ::org::defi_wallet_core::Denom const &self,
-    ::rust::String *return$) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$BaseNft$to_string(
-    ::org::defi_wallet_core::BaseNft const &self,
-    ::rust::String *return$) noexcept;
+bool org$defi_wallet_core$cxxbridge1$Pagination$get_enable(::org::defi_wallet_core::Pagination const &self) noexcept {
+  bool (::org::defi_wallet_core::Pagination::*get_enable$)() const = &::org::defi_wallet_core::Pagination::get_enable;
+  return (self.*get_enable$)();
+}
+
+void org$defi_wallet_core$cxxbridge1$Pagination$get_key(::org::defi_wallet_core::Pagination const &self, ::rust::Vec<::std::uint8_t> *return$) noexcept {
+  ::rust::Vec<::std::uint8_t> (::org::defi_wallet_core::Pagination::*get_key$)() const = &::org::defi_wallet_core::Pagination::get_key;
+  new (return$) ::rust::Vec<::std::uint8_t>((self.*get_key$)());
+}
+
+::std::uint64_t org$defi_wallet_core$cxxbridge1$Pagination$get_offset(::org::defi_wallet_core::Pagination const &self) noexcept {
+  ::std::uint64_t (::org::defi_wallet_core::Pagination::*get_offset$)() const = &::org::defi_wallet_core::Pagination::get_offset;
+  return (self.*get_offset$)();
+}
+
+::std::uint64_t org$defi_wallet_core$cxxbridge1$Pagination$get_limit(::org::defi_wallet_core::Pagination const &self) noexcept {
+  ::std::uint64_t (::org::defi_wallet_core::Pagination::*get_limit$)() const = &::org::defi_wallet_core::Pagination::get_limit;
+  return (self.*get_limit$)();
+}
+
+bool org$defi_wallet_core$cxxbridge1$Pagination$get_count_total(::org::defi_wallet_core::Pagination const &self) noexcept {
+  bool (::org::defi_wallet_core::Pagination::*get_count_total$)() const = &::org::defi_wallet_core::Pagination::get_count_total;
+  return (self.*get_count_total$)();
+}
+
+bool org$defi_wallet_core$cxxbridge1$Pagination$get_reverse(::org::defi_wallet_core::Pagination const &self) noexcept {
+  bool (::org::defi_wallet_core::Pagination::*get_reverse$)() const = &::org::defi_wallet_core::Pagination::get_reverse;
+  return (self.*get_reverse$)();
+}
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_issue_denom_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id, ::rust::String *name, ::rust::String *schema, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_mint_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id, ::rust::String *denom_id, ::rust::String *name, ::rust::String *uri, ::rust::String *data, ::rust::String *recipient, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_edit_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id, ::rust::String *denom_id, ::rust::String *name, ::rust::String *uri, ::rust::String *data, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_transfer_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id, ::rust::String *denom_id, ::rust::String *recipient, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$get_nft_burn_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw *tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String *id, ::rust::String *denom_id, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$GrpcClient$operator$sizeof() noexcept;
+::std::size_t org$defi_wallet_core$cxxbridge1$GrpcClient$operator$alignof() noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$new_grpc_client(::rust::String *grpc_url, ::rust::Box<::org::defi_wallet_core::GrpcClient> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$supply(::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id, ::rust::String *owner, ::std::uint64_t *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$owner(::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id, ::rust::String *owner, ::org::defi_wallet_core::Pagination const &pagination, ::org::defi_wallet_core::Owner *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$collection(::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id, ::org::defi_wallet_core::Pagination const &pagination, ::org::defi_wallet_core::Collection *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$denom(::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id, ::org::defi_wallet_core::Denom *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$denom_by_name(::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_name, ::org::defi_wallet_core::Denom *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$denoms(::org::defi_wallet_core::GrpcClient const &self, ::org::defi_wallet_core::Pagination const &pagination, ::rust::Vec<::org::defi_wallet_core::Denom> *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$GrpcClient$nft(::org::defi_wallet_core::GrpcClient const &self, ::rust::String *denom_id, ::rust::String *token_id, ::org::defi_wallet_core::BaseNft *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Owner$to_string(::org::defi_wallet_core::Owner const &self, ::rust::String *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Collection$to_string(::org::defi_wallet_core::Collection const &self, ::rust::String *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$Denom$to_string(::org::defi_wallet_core::Denom const &self, ::rust::String *return$) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$BaseNft$to_string(::org::defi_wallet_core::BaseNft const &self, ::rust::String *return$) noexcept;
 } // extern "C"
 
 /// creates the signed transaction
 /// for `MsgIssueDenom` from the Chainmain nft module
-::rust::Vec<::std::uint8_t> get_nft_issue_denom_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id,
-    ::rust::String name, ::rust::String schema) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_nft_issue_denom_signed_tx(
-            &tx_info$.value, private_key, &id, &name, &schema, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_nft_issue_denom_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String name, ::rust::String schema) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_nft_issue_denom_signed_tx(&tx_info$.value, private_key, &id, &name, &schema, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgMintNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t>
-get_nft_mint_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                       ::org::defi_wallet_core::PrivateKey const &private_key,
-                       ::rust::String id, ::rust::String denom_id,
-                       ::rust::String name, ::rust::String uri,
-                       ::rust::String data, ::rust::String recipient) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_nft_mint_signed_tx(
-            &tx_info$.value, private_key, &id, &denom_id, &name, &uri, &data,
-            &recipient, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_nft_mint_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id, ::rust::String name, ::rust::String uri, ::rust::String data, ::rust::String recipient) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_nft_mint_signed_tx(&tx_info$.value, private_key, &id, &denom_id, &name, &uri, &data, &recipient, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgEditNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t>
-get_nft_edit_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                       ::org::defi_wallet_core::PrivateKey const &private_key,
-                       ::rust::String id, ::rust::String denom_id,
-                       ::rust::String name, ::rust::String uri,
-                       ::rust::String data) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_nft_edit_signed_tx(
-            &tx_info$.value, private_key, &id, &denom_id, &name, &uri, &data,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_nft_edit_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id, ::rust::String name, ::rust::String uri, ::rust::String data) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_nft_edit_signed_tx(&tx_info$.value, private_key, &id, &denom_id, &name, &uri, &data, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgTransferNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t> get_nft_transfer_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id,
-    ::rust::String denom_id, ::rust::String recipient) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_nft_transfer_signed_tx(
-            &tx_info$.value, private_key, &id, &denom_id, &recipient,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_nft_transfer_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id, ::rust::String recipient) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_nft_transfer_signed_tx(&tx_info$.value, private_key, &id, &denom_id, &recipient, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// creates the signed transaction
 /// for `MsgBurnNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t>
-get_nft_burn_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                       ::org::defi_wallet_core::PrivateKey const &private_key,
-                       ::rust::String id, ::rust::String denom_id) {
-    ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(
-        ::std::move(tx_info));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$get_nft_burn_signed_tx(
-            &tx_info$.value, private_key, &id, &denom_id, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::std::uint8_t> get_nft_burn_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id) {
+  ::rust::ManuallyDrop<::org::defi_wallet_core::CosmosSDKTxInfoRaw> tx_info$(::std::move(tx_info));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$get_nft_burn_signed_tx(&tx_info$.value, private_key, &id, &denom_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::std::size_t GrpcClient::layout::size() noexcept {
-    return org$defi_wallet_core$cxxbridge1$GrpcClient$operator$sizeof();
+  return org$defi_wallet_core$cxxbridge1$GrpcClient$operator$sizeof();
 }
 
 ::std::size_t GrpcClient::layout::align() noexcept {
-    return org$defi_wallet_core$cxxbridge1$GrpcClient$operator$alignof();
+  return org$defi_wallet_core$cxxbridge1$GrpcClient$operator$alignof();
 }
 
 /// Create a new grpc client
 ///
-::rust::Box<::org::defi_wallet_core::GrpcClient>
-new_grpc_client(::rust::String grpc_url) {
-    ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::GrpcClient>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$new_grpc_client(&grpc_url,
-                                                        &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::std::uint64_t GrpcClient::supply(::rust::String denom_id,
-                                   ::rust::String owner) const {
-    ::rust::MaybeUninit<::std::uint64_t> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$GrpcClient$supply(
-            *this, &denom_id, &owner, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::Owner
-GrpcClient::owner(::rust::String denom_id, ::rust::String owner,
-                  ::org::defi_wallet_core::Pagination const &pagination) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Owner> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$GrpcClient$owner(
-            *this, &denom_id, &owner, pagination, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::Collection GrpcClient::collection(
-    ::rust::String denom_id,
-    ::org::defi_wallet_core::Pagination const &pagination) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Collection> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$GrpcClient$collection(
-            *this, &denom_id, pagination, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::Denom
-GrpcClient::denom(::rust::String denom_id) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Denom> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$GrpcClient$denom(*this, &denom_id,
-                                                         &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::Denom
-GrpcClient::denom_by_name(::rust::String denom_name) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::Denom> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$GrpcClient$denom_by_name(
-            *this, &denom_name, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::org::defi_wallet_core::Denom> GrpcClient::denoms(
-    ::org::defi_wallet_core::Pagination const &pagination) const {
-    ::rust::MaybeUninit<::rust::Vec<::org::defi_wallet_core::Denom>> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$GrpcClient$denoms(*this, pagination,
-                                                          &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::org::defi_wallet_core::BaseNft
-GrpcClient::nft(::rust::String denom_id, ::rust::String token_id) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::BaseNft> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$GrpcClient$nft(
-            *this, &denom_id, &token_id, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::org::defi_wallet_core::GrpcClient> new_grpc_client(::rust::String grpc_url) {
+  ::rust::MaybeUninit<::rust::Box<::org::defi_wallet_core::GrpcClient>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$new_grpc_client(&grpc_url, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::std::uint64_t GrpcClient::supply(::rust::String denom_id, ::rust::String owner) const {
+  ::rust::MaybeUninit<::std::uint64_t> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$GrpcClient$supply(*this, &denom_id, &owner, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::Owner GrpcClient::owner(::rust::String denom_id, ::rust::String owner, ::org::defi_wallet_core::Pagination const &pagination) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Owner> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$GrpcClient$owner(*this, &denom_id, &owner, pagination, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::Collection GrpcClient::collection(::rust::String denom_id, ::org::defi_wallet_core::Pagination const &pagination) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Collection> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$GrpcClient$collection(*this, &denom_id, pagination, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::Denom GrpcClient::denom(::rust::String denom_id) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Denom> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$GrpcClient$denom(*this, &denom_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::Denom GrpcClient::denom_by_name(::rust::String denom_name) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::Denom> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$GrpcClient$denom_by_name(*this, &denom_name, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::org::defi_wallet_core::Denom> GrpcClient::denoms(::org::defi_wallet_core::Pagination const &pagination) const {
+  ::rust::MaybeUninit<::rust::Vec<::org::defi_wallet_core::Denom>> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$GrpcClient$denoms(*this, pagination, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::org::defi_wallet_core::BaseNft GrpcClient::nft(::rust::String denom_id, ::rust::String token_id) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::BaseNft> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$GrpcClient$nft(*this, &denom_id, &token_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Owner::to_string() const noexcept {
-    ::rust::MaybeUninit<::rust::String> return$;
-    org$defi_wallet_core$cxxbridge1$Owner$to_string(*this, &return$.value);
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  org$defi_wallet_core$cxxbridge1$Owner$to_string(*this, &return$.value);
+  return ::std::move(return$.value);
 }
 
 ::rust::String Collection::to_string() const noexcept {
-    ::rust::MaybeUninit<::rust::String> return$;
-    org$defi_wallet_core$cxxbridge1$Collection$to_string(*this, &return$.value);
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  org$defi_wallet_core$cxxbridge1$Collection$to_string(*this, &return$.value);
+  return ::std::move(return$.value);
 }
 
 ::rust::String Denom::to_string() const noexcept {
-    ::rust::MaybeUninit<::rust::String> return$;
-    org$defi_wallet_core$cxxbridge1$Denom$to_string(*this, &return$.value);
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  org$defi_wallet_core$cxxbridge1$Denom$to_string(*this, &return$.value);
+  return ::std::move(return$.value);
 }
 
 ::rust::String BaseNft::to_string() const noexcept {
-    ::rust::MaybeUninit<::rust::String> return$;
-    org$defi_wallet_core$cxxbridge1$BaseNft$to_string(*this, &return$.value);
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  org$defi_wallet_core$cxxbridge1$BaseNft$to_string(*this, &return$.value);
+  return ::std::move(return$.value);
 }
 } // namespace defi_wallet_core
 } // namespace org
 
 extern "C" {
-void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$new(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$drop(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$len(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$capacity(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
-::org::defi_wallet_core::IdCollection const *
-cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$data(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$reserve_total(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$set_len(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$truncate(
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr,
-    ::std::size_t len) noexcept;
-
-void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$new(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$drop(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$len(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$capacity(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
-::org::defi_wallet_core::BaseNft const *
-cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$data(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$reserve_total(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$set_len(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$truncate(
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr,
-    ::std::size_t len) noexcept;
-
-::org::defi_wallet_core::GrpcClient *
-cxxbridge1$box$org$defi_wallet_core$GrpcClient$alloc() noexcept;
-void cxxbridge1$box$org$defi_wallet_core$GrpcClient$dealloc(
-    ::org::defi_wallet_core::GrpcClient *) noexcept;
-void cxxbridge1$box$org$defi_wallet_core$GrpcClient$drop(
-    ::rust::Box<::org::defi_wallet_core::GrpcClient> *ptr) noexcept;
-
-void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$new(
-    ::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$drop(
-    ::rust::Vec<::org::defi_wallet_core::Denom> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$Denom$len(
-    ::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$Denom$capacity(
-    ::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
-::org::defi_wallet_core::Denom const *
-cxxbridge1$rust_vec$org$defi_wallet_core$Denom$data(
-    ::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$reserve_total(
-    ::rust::Vec<::org::defi_wallet_core::Denom> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$set_len(
-    ::rust::Vec<::org::defi_wallet_core::Denom> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$truncate(
-    ::rust::Vec<::org::defi_wallet_core::Denom> *ptr,
-    ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$new(::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$drop(::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$len(::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$capacity(::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
+::org::defi_wallet_core::IdCollection const *cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$data(::rust::Vec<::org::defi_wallet_core::IdCollection> const *ptr) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$reserve_total(::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$set_len(::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$truncate(::rust::Vec<::org::defi_wallet_core::IdCollection> *ptr, ::std::size_t len) noexcept;
+
+void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$new(::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$drop(::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$len(::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$capacity(::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
+::org::defi_wallet_core::BaseNft const *cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$data(::rust::Vec<::org::defi_wallet_core::BaseNft> const *ptr) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$reserve_total(::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$set_len(::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$truncate(::rust::Vec<::org::defi_wallet_core::BaseNft> *ptr, ::std::size_t len) noexcept;
+
+::org::defi_wallet_core::GrpcClient *cxxbridge1$box$org$defi_wallet_core$GrpcClient$alloc() noexcept;
+void cxxbridge1$box$org$defi_wallet_core$GrpcClient$dealloc(::org::defi_wallet_core::GrpcClient *) noexcept;
+void cxxbridge1$box$org$defi_wallet_core$GrpcClient$drop(::rust::Box<::org::defi_wallet_core::GrpcClient> *ptr) noexcept;
+
+void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$new(::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$drop(::rust::Vec<::org::defi_wallet_core::Denom> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$Denom$len(::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$org$defi_wallet_core$Denom$capacity(::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
+::org::defi_wallet_core::Denom const *cxxbridge1$rust_vec$org$defi_wallet_core$Denom$data(::rust::Vec<::org::defi_wallet_core::Denom> const *ptr) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$reserve_total(::rust::Vec<::org::defi_wallet_core::Denom> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$set_len(::rust::Vec<::org::defi_wallet_core::Denom> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$org$defi_wallet_core$Denom$truncate(::rust::Vec<::org::defi_wallet_core::Denom> *ptr, ::std::size_t len) noexcept;
 } // extern "C"
 
 namespace rust {
 inline namespace cxxbridge1 {
-template <> Vec<::org::defi_wallet_core::IdCollection>::Vec() noexcept {
-    cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$new(this);
+template <>
+Vec<::org::defi_wallet_core::IdCollection>::Vec() noexcept {
+  cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$new(this);
 }
-template <> void Vec<::org::defi_wallet_core::IdCollection>::drop() noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$drop(this);
+template <>
+void Vec<::org::defi_wallet_core::IdCollection>::drop() noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$drop(this);
 }
 template <>
-::std::size_t
-Vec<::org::defi_wallet_core::IdCollection>::size() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$len(this);
+::std::size_t Vec<::org::defi_wallet_core::IdCollection>::size() const noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$len(this);
 }
 template <>
-::std::size_t
-Vec<::org::defi_wallet_core::IdCollection>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$capacity(this);
+::std::size_t Vec<::org::defi_wallet_core::IdCollection>::capacity() const noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$capacity(this);
 }
 template <>
-::org::defi_wallet_core::IdCollection const *
-Vec<::org::defi_wallet_core::IdCollection>::data() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$data(this);
+::org::defi_wallet_core::IdCollection const *Vec<::org::defi_wallet_core::IdCollection>::data() const noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$data(this);
 }
 template <>
-void Vec<::org::defi_wallet_core::IdCollection>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$reserve_total(
-        this, new_cap);
+void Vec<::org::defi_wallet_core::IdCollection>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::org::defi_wallet_core::IdCollection>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$set_len(this,
-                                                                         len);
+void Vec<::org::defi_wallet_core::IdCollection>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$set_len(this, len);
 }
 template <>
 void Vec<::org::defi_wallet_core::IdCollection>::truncate(::std::size_t len) {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$truncate(this,
-                                                                          len);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$IdCollection$truncate(this, len);
 }
-template <> Vec<::org::defi_wallet_core::BaseNft>::Vec() noexcept {
-    cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$new(this);
+template <>
+Vec<::org::defi_wallet_core::BaseNft>::Vec() noexcept {
+  cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$new(this);
 }
-template <> void Vec<::org::defi_wallet_core::BaseNft>::drop() noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$drop(this);
+template <>
+void Vec<::org::defi_wallet_core::BaseNft>::drop() noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$drop(this);
 }
 template <>
 ::std::size_t Vec<::org::defi_wallet_core::BaseNft>::size() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$len(this);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$len(this);
 }
 template <>
 ::std::size_t Vec<::org::defi_wallet_core::BaseNft>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$capacity(this);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$capacity(this);
 }
 template <>
-::org::defi_wallet_core::BaseNft const *
-Vec<::org::defi_wallet_core::BaseNft>::data() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$data(this);
+::org::defi_wallet_core::BaseNft const *Vec<::org::defi_wallet_core::BaseNft>::data() const noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$data(this);
 }
 template <>
-void Vec<::org::defi_wallet_core::BaseNft>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$reserve_total(
-        this, new_cap);
+void Vec<::org::defi_wallet_core::BaseNft>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::org::defi_wallet_core::BaseNft>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$set_len(this, len);
+void Vec<::org::defi_wallet_core::BaseNft>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$set_len(this, len);
 }
 template <>
 void Vec<::org::defi_wallet_core::BaseNft>::truncate(::std::size_t len) {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$truncate(this, len);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$BaseNft$truncate(this, len);
 }
 template <>
-::org::defi_wallet_core::GrpcClient *
-Box<::org::defi_wallet_core::GrpcClient>::allocation::alloc() noexcept {
-    return cxxbridge1$box$org$defi_wallet_core$GrpcClient$alloc();
+::org::defi_wallet_core::GrpcClient *Box<::org::defi_wallet_core::GrpcClient>::allocation::alloc() noexcept {
+  return cxxbridge1$box$org$defi_wallet_core$GrpcClient$alloc();
 }
 template <>
-void Box<::org::defi_wallet_core::GrpcClient>::allocation::dealloc(
-    ::org::defi_wallet_core::GrpcClient *ptr) noexcept {
-    cxxbridge1$box$org$defi_wallet_core$GrpcClient$dealloc(ptr);
+void Box<::org::defi_wallet_core::GrpcClient>::allocation::dealloc(::org::defi_wallet_core::GrpcClient *ptr) noexcept {
+  cxxbridge1$box$org$defi_wallet_core$GrpcClient$dealloc(ptr);
 }
-template <> void Box<::org::defi_wallet_core::GrpcClient>::drop() noexcept {
-    cxxbridge1$box$org$defi_wallet_core$GrpcClient$drop(this);
+template <>
+void Box<::org::defi_wallet_core::GrpcClient>::drop() noexcept {
+  cxxbridge1$box$org$defi_wallet_core$GrpcClient$drop(this);
 }
-template <> Vec<::org::defi_wallet_core::Denom>::Vec() noexcept {
-    cxxbridge1$rust_vec$org$defi_wallet_core$Denom$new(this);
+template <>
+Vec<::org::defi_wallet_core::Denom>::Vec() noexcept {
+  cxxbridge1$rust_vec$org$defi_wallet_core$Denom$new(this);
 }
-template <> void Vec<::org::defi_wallet_core::Denom>::drop() noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$drop(this);
+template <>
+void Vec<::org::defi_wallet_core::Denom>::drop() noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$drop(this);
 }
 template <>
 ::std::size_t Vec<::org::defi_wallet_core::Denom>::size() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$len(this);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$len(this);
 }
 template <>
 ::std::size_t Vec<::org::defi_wallet_core::Denom>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$capacity(this);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$capacity(this);
 }
 template <>
-::org::defi_wallet_core::Denom const *
-Vec<::org::defi_wallet_core::Denom>::data() const noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$data(this);
+::org::defi_wallet_core::Denom const *Vec<::org::defi_wallet_core::Denom>::data() const noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$data(this);
 }
 template <>
-void Vec<::org::defi_wallet_core::Denom>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$reserve_total(
-        this, new_cap);
+void Vec<::org::defi_wallet_core::Denom>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$reserve_total(this, new_cap);
 }
 template <>
 void Vec<::org::defi_wallet_core::Denom>::set_len(::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$set_len(this, len);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$set_len(this, len);
 }
 template <>
 void Vec<::org::defi_wallet_core::Denom>::truncate(::std::size_t len) {
-    return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$truncate(this, len);
+  return cxxbridge1$rust_vec$org$defi_wallet_core$Denom$truncate(this, len);
 }
 } // namespace cxxbridge1
 } // namespace rust
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.h
index 6a017022..d62686cc 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/nft.rs.h
@@ -20,708 +20,775 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_SLICE
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -731,10 +798,10 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -753,218 +820,199 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct Denom;
-struct BaseNft;
-struct IdCollection;
-struct Owner;
-struct Collection;
-using Pagination = ::org::defi_wallet_core::Pagination;
-struct GrpcClient;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    struct Denom;
+    struct BaseNft;
+    struct IdCollection;
+    struct Owner;
+    struct Collection;
+    using Pagination = ::org::defi_wallet_core::Pagination;
+    struct GrpcClient;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Denom
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Denom
 struct Denom final {
-    ::rust::String id;
-    ::rust::String name;
-    ::rust::String schema;
-    ::rust::String creator;
+  ::rust::String id;
+  ::rust::String name;
+  ::rust::String schema;
+  ::rust::String creator;
 
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Denom
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$BaseNft
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$BaseNft
 struct BaseNft final {
-    ::rust::String id;
-    ::rust::String name;
-    ::rust::String uri;
-    ::rust::String data;
-    ::rust::String owner;
-
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String id;
+  ::rust::String name;
+  ::rust::String uri;
+  ::rust::String data;
+  ::rust::String owner;
+
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$BaseNft
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$IdCollection
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$IdCollection
 struct IdCollection final {
-    ::rust::String denom_id;
-    ::rust::Vec<::rust::String> token_ids;
+  ::rust::String denom_id;
+  ::rust::Vec<::rust::String> token_ids;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$IdCollection
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Owner
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Owner
 struct Owner final {
-    ::rust::String address;
-    ::rust::Vec<::org::defi_wallet_core::IdCollection> id_collections;
+  ::rust::String address;
+  ::rust::Vec<::org::defi_wallet_core::IdCollection> id_collections;
 
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Owner
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$Collection
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$Collection
 struct Collection final {
-    bool denom_option;
-    ::org::defi_wallet_core::Denom denom_value;
-    ::rust::Vec<::org::defi_wallet_core::BaseNft> nfts;
+  bool denom_option;
+  ::org::defi_wallet_core::Denom denom_value;
+  ::rust::Vec<::org::defi_wallet_core::BaseNft> nfts;
 
-    ::rust::String to_string() const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::rust::String to_string() const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$Collection
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$GrpcClient
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$GrpcClient
 struct GrpcClient final : public ::rust::Opaque {
-    /// Supply queries the total supply of a given denom or owner
-    ///
-    ::std::uint64_t supply(::rust::String denom_id, ::rust::String owner) const;
-
-    /// Owner queries the NFTs of the specified owner
-    ///
-    ::org::defi_wallet_core::Owner
-    owner(::rust::String denom_id, ::rust::String owner,
-          ::org::defi_wallet_core::Pagination const &pagination) const;
-
-    /// Collection queries the NFTs of the specified denom
-    ///
-    ::org::defi_wallet_core::Collection
-    collection(::rust::String denom_id,
-               ::org::defi_wallet_core::Pagination const &pagination) const;
-
-    /// Denom queries the definition of a given denom
-    ///
-    ::org::defi_wallet_core::Denom denom(::rust::String denom_id) const;
-
-    /// DenomByName queries the definition of a given denom by name
-    ///
-    ::org::defi_wallet_core::Denom
-    denom_by_name(::rust::String denom_name) const;
-
-    /// Denoms queries all the denoms
-    ///
-    ::rust::Vec<::org::defi_wallet_core::Denom>
-    denoms(::org::defi_wallet_core::Pagination const &pagination) const;
-
-    /// NFT queries the NFT for the given denom and token ID
-    ///
-    ::org::defi_wallet_core::BaseNft nft(::rust::String denom_id,
-                                         ::rust::String token_id) const;
-
-    ~GrpcClient() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// Supply queries the total supply of a given denom or owner
+  ///
+  ::std::uint64_t supply(::rust::String denom_id, ::rust::String owner) const;
+
+  /// Owner queries the NFTs of the specified owner
+  ///
+  ::org::defi_wallet_core::Owner owner(::rust::String denom_id, ::rust::String owner, ::org::defi_wallet_core::Pagination const &pagination) const;
+
+  /// Collection queries the NFTs of the specified denom
+  ///
+  ::org::defi_wallet_core::Collection collection(::rust::String denom_id, ::org::defi_wallet_core::Pagination const &pagination) const;
+
+  /// Denom queries the definition of a given denom
+  ///
+  ::org::defi_wallet_core::Denom denom(::rust::String denom_id) const;
+
+  /// DenomByName queries the definition of a given denom by name
+  ///
+  ::org::defi_wallet_core::Denom denom_by_name(::rust::String denom_name) const;
+
+  /// Denoms queries all the denoms
+  ///
+  ::rust::Vec<::org::defi_wallet_core::Denom> denoms(::org::defi_wallet_core::Pagination const &pagination) const;
+
+  /// NFT queries the NFT for the given denom and token ID
+  ///
+  ::org::defi_wallet_core::BaseNft nft(::rust::String denom_id, ::rust::String token_id) const;
+
+  ~GrpcClient() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$GrpcClient
 
 /// creates the signed transaction
 /// for `MsgIssueDenom` from the Chainmain nft module
-::rust::Vec<::std::uint8_t> get_nft_issue_denom_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id,
-    ::rust::String name, ::rust::String schema);
+::rust::Vec<::std::uint8_t> get_nft_issue_denom_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String name, ::rust::String schema);
 
 /// creates the signed transaction
 /// for `MsgMintNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t>
-get_nft_mint_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                       ::org::defi_wallet_core::PrivateKey const &private_key,
-                       ::rust::String id, ::rust::String denom_id,
-                       ::rust::String name, ::rust::String uri,
-                       ::rust::String data, ::rust::String recipient);
+::rust::Vec<::std::uint8_t> get_nft_mint_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id, ::rust::String name, ::rust::String uri, ::rust::String data, ::rust::String recipient);
 
 /// creates the signed transaction
 /// for `MsgEditNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t>
-get_nft_edit_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                       ::org::defi_wallet_core::PrivateKey const &private_key,
-                       ::rust::String id, ::rust::String denom_id,
-                       ::rust::String name, ::rust::String uri,
-                       ::rust::String data);
+::rust::Vec<::std::uint8_t> get_nft_edit_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id, ::rust::String name, ::rust::String uri, ::rust::String data);
 
 /// creates the signed transaction
 /// for `MsgTransferNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t> get_nft_transfer_signed_tx(
-    ::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-    ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id,
-    ::rust::String denom_id, ::rust::String recipient);
+::rust::Vec<::std::uint8_t> get_nft_transfer_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id, ::rust::String recipient);
 
 /// creates the signed transaction
 /// for `MsgBurnNft` from the Chainmain nft module
-::rust::Vec<::std::uint8_t>
-get_nft_burn_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info,
-                       ::org::defi_wallet_core::PrivateKey const &private_key,
-                       ::rust::String id, ::rust::String denom_id);
+::rust::Vec<::std::uint8_t> get_nft_burn_signed_tx(::org::defi_wallet_core::CosmosSDKTxInfoRaw tx_info, ::org::defi_wallet_core::PrivateKey const &private_key, ::rust::String id, ::rust::String denom_id);
 
 /// Create a new grpc client
 ///
-::rust::Box<::org::defi_wallet_core::GrpcClient>
-new_grpc_client(::rust::String grpc_url);
+::rust::Box<::org::defi_wallet_core::GrpcClient> new_grpc_client(::rust::String grpc_url);
 } // namespace defi_wallet_core
 } // namespace org
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.cc b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.cc
index a580e2c8..13a03d9d 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.cc
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.cc
@@ -18,575 +18,621 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
 class Opaque;
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_SLICE
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+template <typename T>
+void Slice<T>::swap(Slice &rhs) noexcept {
+  std::swap(*this, rhs);
 }
 #endif // CXXBRIDGE1_RUST_SLICE
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -596,21 +642,21 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_ERROR
 #define CXXBRIDGE1_RUST_ERROR
 class Error final : public std::exception {
-  public:
-    Error(const Error &);
-    Error(Error &&) noexcept;
-    ~Error() noexcept override;
+public:
+  Error(const Error &);
+  Error(Error &&) noexcept;
+  ~Error() noexcept override;
 
-    Error &operator=(const Error &) &;
-    Error &operator=(Error &&) &noexcept;
+  Error &operator=(const Error &) &;
+  Error &operator=(Error &&) &noexcept;
 
-    const char *what() const noexcept override;
+  const char *what() const noexcept override;
 
-  private:
-    Error() noexcept = default;
-    friend impl<Error>;
-    const char *msg;
-    std::size_t len;
+private:
+  Error() noexcept = default;
+  friend impl<Error>;
+  const char *msg;
+  std::size_t len;
 };
 #endif // CXXBRIDGE1_RUST_ERROR
 
@@ -629,537 +675,443 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 
 namespace repr {
 struct PtrLen final {
-    void *ptr;
-    ::std::size_t len;
+  void *ptr;
+  ::std::size_t len;
 };
 } // namespace repr
 
 namespace detail {
-template <typename T, typename = void *> struct operator_new {
-    void *operator()(::std::size_t sz) { return ::operator new(sz); }
+template <typename T, typename = void *>
+struct operator_new {
+  void *operator()(::std::size_t sz) { return ::operator new(sz); }
 };
 
 template <typename T>
 struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
-    void *operator()(::std::size_t sz) { return T::operator new(sz); }
+  void *operator()(::std::size_t sz) { return T::operator new(sz); }
 };
 } // namespace detail
 
-template <typename T> union MaybeUninit {
-    T value;
-    void *operator new(::std::size_t sz) {
-        return detail::operator_new<T>{}(sz);
-    }
-    MaybeUninit() {}
-    ~MaybeUninit() {}
+template <typename T>
+union MaybeUninit {
+  T value;
+  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
+  MaybeUninit() {}
+  ~MaybeUninit() {}
 };
 
 namespace {
-template <> class impl<Error> final {
-  public:
-    static Error error(repr::PtrLen repr) noexcept {
-        Error error;
-        error.msg = static_cast<char const *>(repr.ptr);
-        error.len = repr.len;
-        return error;
-    }
+template <>
+class impl<Error> final {
+public:
+  static Error error(repr::PtrLen repr) noexcept {
+    Error error;
+    error.msg = static_cast<char const *>(repr.ptr);
+    error.len = repr.len;
+    return error;
+  }
 };
 } // namespace
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct U256;
-struct U256WithOverflow;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    struct U256;
+    struct U256WithOverflow;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256
 struct U256 final {
-    ::std::array<::std::uint64_t, 4> data;
-
-    /// Convert to Decimal String
-    ///
-    ::rust::String to_string() const noexcept;
-
-    /// Addition which saturates at the maximum value.
-    ///
-    ::org::defi_wallet_core::U256
-    saturating_add(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Subtraction which saturates at zero.
-    ///
-    ::org::defi_wallet_core::U256
-    saturating_sub(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Multiplication which saturates at maximum value.
-    ///
-    ::org::defi_wallet_core::U256
-    saturating_mul(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the addition along with a boolean indicating whether an
-    /// arithmetic overflow would occur. If an overflow would have occurred then
-    /// the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_add(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the subtraction along with a boolean indicating whether an
-    /// arithmetic overflow would occur. If an overflow would have occurred then
-    /// the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_sub(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the multiplication along with a boolean indicating whether an
-    /// arithmetic overflow would occur. If an overflow would have occurred then
-    /// the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_mul(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the fast exponentiation by squaring along with a boolean
-    /// indicating whether an arithmetic overflow would occur. If an overflow
-    /// would have occurred then the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_pow(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Negates self in an overflowing fashion.
-    /// Returns !self + 1 using wrapping operations to return the value that
-    /// represents the negation of this unsigned value. Note that for positive
-    /// unsigned values overflow always occurs, but negating 0 does not
-    /// overflow.
-    ::org::defi_wallet_core::U256WithOverflow overflowing_neg() const noexcept;
-
-    /// add, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    add(::org::defi_wallet_core::U256 other) const;
-
-    /// sub, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    sub(::org::defi_wallet_core::U256 other) const;
-
-    /// mul, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    mul(::org::defi_wallet_core::U256 other) const;
-
-    /// pow, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    pow(::org::defi_wallet_core::U256 other) const;
-
-    /// Negates self in an overflowing fashion.
-    /// Returns !self + 1 using wrapping operations to return the value that
-    /// represents the negation of this unsigned value.
-    ::org::defi_wallet_core::U256 neg() const noexcept;
-
-    /// Returns a pair `(self / other)`
-    ///
-    ::org::defi_wallet_core::U256
-    div(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns a pair `(self % other)`
-    ///
-    ::org::defi_wallet_core::U256
-    rem(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Write to the slice in big-endian format.
-    ///
-    void to_big_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
-
-    /// Write to the slice in little-endian format.
-    ///
-    void to_little_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
-
-    /// Format the output for the user which prefer to see values in ether
-    /// (instead of wei) Divides the input by 1e18
-    ::org::defi_wallet_core::U256 format_ether() const noexcept;
-
-    /// Convert to common ethereum unit types: ether, gwei, or wei
-    /// formatted in _ETH decimals_ (e.g. "1.50000...") wrapped as string
-    ::rust::String format_units(::rust::String units) const;
-
-    bool operator==(U256 const &) const noexcept;
-    bool operator!=(U256 const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::std::array<::std::uint64_t, 4> data;
+
+  /// Convert to Decimal String
+  ///
+  ::rust::String to_string() const noexcept;
+
+  /// Addition which saturates at the maximum value.
+  ///
+  ::org::defi_wallet_core::U256 saturating_add(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Subtraction which saturates at zero.
+  ///
+  ::org::defi_wallet_core::U256 saturating_sub(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Multiplication which saturates at maximum value.
+  ///
+  ::org::defi_wallet_core::U256 saturating_mul(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the addition along with a boolean indicating whether an arithmetic overflow
+  /// would occur. If an overflow would have occurred then the wrapped value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_add(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the subtraction along with a boolean indicating whether an arithmetic overflow
+  /// would occur. If an overflow would have occurred then the wrapped value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_sub(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the multiplication along with a boolean indicating whether an arithmetic overflow
+  /// would occur. If an overflow would have occurred then the wrapped value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_mul(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the fast exponentiation by squaring along with a boolean indicating whether an
+  /// arithmetic overflow would occur. If an overflow would have occurred then the wrapped
+  /// value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_pow(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Negates self in an overflowing fashion.
+  /// Returns !self + 1 using wrapping operations to return the value that represents
+  /// the negation of this unsigned value. Note that for positive unsigned values
+  /// overflow always occurs, but negating 0 does not overflow.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_neg() const noexcept;
+
+  /// add, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 add(::org::defi_wallet_core::U256 other) const;
+
+  /// sub, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 sub(::org::defi_wallet_core::U256 other) const;
+
+  /// mul, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 mul(::org::defi_wallet_core::U256 other) const;
+
+  /// pow, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 pow(::org::defi_wallet_core::U256 other) const;
+
+  /// Negates self in an overflowing fashion.
+  /// Returns !self + 1 using wrapping operations to return the value that represents
+  /// the negation of this unsigned value.
+  ::org::defi_wallet_core::U256 neg() const noexcept;
+
+  /// Returns a pair `(self / other)`
+  ///
+  ::org::defi_wallet_core::U256 div(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns a pair `(self % other)`
+  ///
+  ::org::defi_wallet_core::U256 rem(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Write to the slice in big-endian format.
+  ///
+  void to_big_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
+
+  /// Write to the slice in little-endian format.
+  ///
+  void to_little_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
+
+  /// Format the output for the user which prefer to see values in ether (instead of wei)
+  /// Divides the input by 1e18
+  ::org::defi_wallet_core::U256 format_ether() const noexcept;
+
+  /// Convert to common ethereum unit types: ether, gwei, or wei
+  /// formatted in _ETH decimals_ (e.g. "1.50000...") wrapped as string
+  ::rust::String format_units(::rust::String units) const;
+
+  bool operator==(U256 const &) const noexcept;
+  bool operator!=(U256 const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256WithOverflow
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256WithOverflow
 struct U256WithOverflow final {
-    ::org::defi_wallet_core::U256 result;
-    bool overflow;
+  ::org::defi_wallet_core::U256 result;
+  bool overflow;
 
-    bool operator==(U256WithOverflow const &) const noexcept;
-    bool operator!=(U256WithOverflow const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  bool operator==(U256WithOverflow const &) const noexcept;
+  bool operator!=(U256WithOverflow const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256WithOverflow
 
 extern "C" {
-bool org$defi_wallet_core$cxxbridge1$U256$operator$eq(U256 const &,
-                                                      U256 const &) noexcept;
-bool org$defi_wallet_core$cxxbridge1$U256WithOverflow$operator$eq(
-    U256WithOverflow const &, U256WithOverflow const &) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$u256_from_dec_str(
-    ::rust::String *value, ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$u256_from_str_radix(
-    ::rust::String *txt, ::std::uint32_t radix,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::org::defi_wallet_core::U256
-org$defi_wallet_core$cxxbridge1$u256_max_value() noexcept;
-
-void org$defi_wallet_core$cxxbridge1$U256$to_string(
-    ::org::defi_wallet_core::U256 const &self,
-    ::rust::String *return$) noexcept;
-
-::org::defi_wallet_core::U256
-org$defi_wallet_core$cxxbridge1$U256$saturating_add(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256
-org$defi_wallet_core$cxxbridge1$U256$saturating_sub(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256
-org$defi_wallet_core$cxxbridge1$U256$saturating_mul(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256WithOverflow
-org$defi_wallet_core$cxxbridge1$U256$overflowing_add(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256WithOverflow
-org$defi_wallet_core$cxxbridge1$U256$overflowing_sub(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256WithOverflow
-org$defi_wallet_core$cxxbridge1$U256$overflowing_mul(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256WithOverflow
-org$defi_wallet_core$cxxbridge1$U256$overflowing_pow(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256WithOverflow
-org$defi_wallet_core$cxxbridge1$U256$overflowing_neg(
-    ::org::defi_wallet_core::U256 const &self) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$add(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$sub(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$mul(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$pow(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$neg(
-    ::org::defi_wallet_core::U256 const &self) noexcept;
-
-::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$div(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$rem(
-    ::org::defi_wallet_core::U256 const &self,
-    ::org::defi_wallet_core::U256 other) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$U256$to_big_endian(
-    ::org::defi_wallet_core::U256 const &self,
-    ::rust::Vec<::std::uint8_t> &bytes) noexcept;
-
-void org$defi_wallet_core$cxxbridge1$U256$to_little_endian(
-    ::org::defi_wallet_core::U256 const &self,
-    ::rust::Vec<::std::uint8_t> &bytes) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$parse_ether(
-    ::rust::String *eth, ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$parse_units(
-    ::rust::String *amount, ::rust::String *units,
-    ::org::defi_wallet_core::U256 *return$) noexcept;
-
-::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$format_ether(
-    ::org::defi_wallet_core::U256 const &self) noexcept;
-
-::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$format_units(
-    ::org::defi_wallet_core::U256 const &self, ::rust::String *units,
-    ::rust::String *return$) noexcept;
+bool org$defi_wallet_core$cxxbridge1$U256$operator$eq(U256 const &, U256 const &) noexcept;
+bool org$defi_wallet_core$cxxbridge1$U256WithOverflow$operator$eq(U256WithOverflow const &, U256WithOverflow const &) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$u256_from_dec_str(::rust::String *value, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$u256_from_str_radix(::rust::String *txt, ::std::uint32_t radix, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$u256_max_value() noexcept;
+
+void org$defi_wallet_core$cxxbridge1$U256$to_string(::org::defi_wallet_core::U256 const &self, ::rust::String *return$) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$saturating_add(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$saturating_sub(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$saturating_mul(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256WithOverflow org$defi_wallet_core$cxxbridge1$U256$overflowing_add(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256WithOverflow org$defi_wallet_core$cxxbridge1$U256$overflowing_sub(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256WithOverflow org$defi_wallet_core$cxxbridge1$U256$overflowing_mul(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256WithOverflow org$defi_wallet_core$cxxbridge1$U256$overflowing_pow(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256WithOverflow org$defi_wallet_core$cxxbridge1$U256$overflowing_neg(::org::defi_wallet_core::U256 const &self) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$add(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$sub(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$mul(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$pow(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$neg(::org::defi_wallet_core::U256 const &self) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$div(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$rem(::org::defi_wallet_core::U256 const &self, ::org::defi_wallet_core::U256 other) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$U256$to_big_endian(::org::defi_wallet_core::U256 const &self, ::rust::Vec<::std::uint8_t> &bytes) noexcept;
+
+void org$defi_wallet_core$cxxbridge1$U256$to_little_endian(::org::defi_wallet_core::U256 const &self, ::rust::Vec<::std::uint8_t> &bytes) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$parse_ether(::rust::String *eth, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$parse_units(::rust::String *amount, ::rust::String *units, ::org::defi_wallet_core::U256 *return$) noexcept;
+
+::org::defi_wallet_core::U256 org$defi_wallet_core$cxxbridge1$U256$format_ether(::org::defi_wallet_core::U256 const &self) noexcept;
+
+::rust::repr::PtrLen org$defi_wallet_core$cxxbridge1$U256$format_units(::org::defi_wallet_core::U256 const &self, ::rust::String *units, ::rust::String *return$) noexcept;
 } // extern "C"
 
 bool U256::operator==(U256 const &rhs) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$operator$eq(*this, rhs);
+  return org$defi_wallet_core$cxxbridge1$U256$operator$eq(*this, rhs);
 }
 
 bool U256::operator!=(U256 const &rhs) const noexcept {
-    return !(*this == rhs);
+  return !(*this == rhs);
 }
 
 bool U256WithOverflow::operator==(U256WithOverflow const &rhs) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256WithOverflow$operator$eq(*this,
-                                                                        rhs);
+  return org$defi_wallet_core$cxxbridge1$U256WithOverflow$operator$eq(*this, rhs);
 }
 
 bool U256WithOverflow::operator!=(U256WithOverflow const &rhs) const noexcept {
-    return !(*this == rhs);
+  return !(*this == rhs);
 }
 
 /// Convert from a decimal string.
 ///
 ::org::defi_wallet_core::U256 u256(::rust::String value) {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$u256_from_dec_str(&value,
-                                                          &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// Converts a string slice in a given base to an integer. Only supports radixes
-/// of 10 and 16.
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$u256_from_dec_str(&value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+/// Converts a string slice in a given base to an integer. Only supports radixes of 10
+/// and 16.
 ::org::defi_wallet_core::U256 u256(::rust::String txt, ::std::uint32_t radix) {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$u256_from_str_radix(&txt, radix,
-                                                            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$u256_from_str_radix(&txt, radix, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// The maximum value which can be inhabited by this type.
 ///
 ::org::defi_wallet_core::U256 u256_max_value() noexcept {
-    return org$defi_wallet_core$cxxbridge1$u256_max_value();
+  return org$defi_wallet_core$cxxbridge1$u256_max_value();
 }
 
 ::rust::String U256::to_string() const noexcept {
-    ::rust::MaybeUninit<::rust::String> return$;
-    org$defi_wallet_core$cxxbridge1$U256$to_string(*this, &return$.value);
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  org$defi_wallet_core$cxxbridge1$U256$to_string(*this, &return$.value);
+  return ::std::move(return$.value);
 }
 
-::org::defi_wallet_core::U256
-U256::saturating_add(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$saturating_add(*this, other);
+::org::defi_wallet_core::U256 U256::saturating_add(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$saturating_add(*this, other);
 }
 
-::org::defi_wallet_core::U256
-U256::saturating_sub(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$saturating_sub(*this, other);
+::org::defi_wallet_core::U256 U256::saturating_sub(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$saturating_sub(*this, other);
 }
 
-::org::defi_wallet_core::U256
-U256::saturating_mul(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$saturating_mul(*this, other);
+::org::defi_wallet_core::U256 U256::saturating_mul(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$saturating_mul(*this, other);
 }
 
-::org::defi_wallet_core::U256WithOverflow
-U256::overflowing_add(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$overflowing_add(*this, other);
+::org::defi_wallet_core::U256WithOverflow U256::overflowing_add(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$overflowing_add(*this, other);
 }
 
-::org::defi_wallet_core::U256WithOverflow
-U256::overflowing_sub(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$overflowing_sub(*this, other);
+::org::defi_wallet_core::U256WithOverflow U256::overflowing_sub(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$overflowing_sub(*this, other);
 }
 
-::org::defi_wallet_core::U256WithOverflow
-U256::overflowing_mul(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$overflowing_mul(*this, other);
+::org::defi_wallet_core::U256WithOverflow U256::overflowing_mul(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$overflowing_mul(*this, other);
 }
 
-::org::defi_wallet_core::U256WithOverflow
-U256::overflowing_pow(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$overflowing_pow(*this, other);
+::org::defi_wallet_core::U256WithOverflow U256::overflowing_pow(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$overflowing_pow(*this, other);
 }
 
-::org::defi_wallet_core::U256WithOverflow
-U256::overflowing_neg() const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$overflowing_neg(*this);
+::org::defi_wallet_core::U256WithOverflow U256::overflowing_neg() const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$overflowing_neg(*this);
 }
 
-::org::defi_wallet_core::U256
-U256::add(::org::defi_wallet_core::U256 other) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$U256$add(*this, other, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::U256 U256::add(::org::defi_wallet_core::U256 other) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$U256$add(*this, other, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::org::defi_wallet_core::U256
-U256::sub(::org::defi_wallet_core::U256 other) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$U256$sub(*this, other, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::U256 U256::sub(::org::defi_wallet_core::U256 other) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$U256$sub(*this, other, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::org::defi_wallet_core::U256
-U256::mul(::org::defi_wallet_core::U256 other) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$U256$mul(*this, other, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::U256 U256::mul(::org::defi_wallet_core::U256 other) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$U256$mul(*this, other, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::org::defi_wallet_core::U256
-U256::pow(::org::defi_wallet_core::U256 other) const {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$U256$pow(*this, other, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::U256 U256::pow(::org::defi_wallet_core::U256 other) const {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$U256$pow(*this, other, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::org::defi_wallet_core::U256 U256::neg() const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$neg(*this);
+  return org$defi_wallet_core$cxxbridge1$U256$neg(*this);
 }
 
-::org::defi_wallet_core::U256
-U256::div(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$div(*this, other);
+::org::defi_wallet_core::U256 U256::div(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$div(*this, other);
 }
 
-::org::defi_wallet_core::U256
-U256::rem(::org::defi_wallet_core::U256 other) const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$rem(*this, other);
+::org::defi_wallet_core::U256 U256::rem(::org::defi_wallet_core::U256 other) const noexcept {
+  return org$defi_wallet_core$cxxbridge1$U256$rem(*this, other);
 }
 
 void U256::to_big_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept {
-    org$defi_wallet_core$cxxbridge1$U256$to_big_endian(*this, bytes);
+  org$defi_wallet_core$cxxbridge1$U256$to_big_endian(*this, bytes);
 }
 
 void U256::to_little_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept {
-    org$defi_wallet_core$cxxbridge1$U256$to_little_endian(*this, bytes);
+  org$defi_wallet_core$cxxbridge1$U256$to_little_endian(*this, bytes);
 }
 
 /// Converts the input to a U256 and converts from Ether to Wei.
 ///
 ::org::defi_wallet_core::U256 parse_ether(::rust::String eth) {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$parse_ether(&eth, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$parse_ether(&eth, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// Multiplies the provided amount with 10^{units} provided.
 ///
-::org::defi_wallet_core::U256 parse_units(::rust::String amount,
-                                          ::rust::String units) {
-    ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
-    ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$parse_units(
-        &amount, &units, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::org::defi_wallet_core::U256 parse_units(::rust::String amount, ::rust::String units) {
+  ::rust::MaybeUninit<::org::defi_wallet_core::U256> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$parse_units(&amount, &units, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::org::defi_wallet_core::U256 U256::format_ether() const noexcept {
-    return org$defi_wallet_core$cxxbridge1$U256$format_ether(*this);
+  return org$defi_wallet_core$cxxbridge1$U256$format_ether(*this);
 }
 
 ::rust::String U256::format_units(::rust::String units) const {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        org$defi_wallet_core$cxxbridge1$U256$format_units(*this, &units,
-                                                          &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = org$defi_wallet_core$cxxbridge1$U256$format_units(*this, &units, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 } // namespace defi_wallet_core
 } // namespace org
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.h
index edca884e..ee89705f 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/defi-wallet-core-cpp/src/uint.rs.h
@@ -18,575 +18,621 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
 class Opaque;
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_SLICE
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+template <typename T>
+void Slice<T>::swap(Slice &rhs) noexcept {
+  std::swap(*this, rhs);
 }
 #endif // CXXBRIDGE1_RUST_SLICE
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -608,183 +654,174 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace org {
-namespace defi_wallet_core {
-struct U256;
-struct U256WithOverflow;
-} // namespace defi_wallet_core
-} // namespace org
+  namespace defi_wallet_core {
+    struct U256;
+    struct U256WithOverflow;
+  }
+}
 
 namespace org {
 namespace defi_wallet_core {
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256
 struct U256 final {
-    ::std::array<::std::uint64_t, 4> data;
-
-    /// Convert to Decimal String
-    ///
-    ::rust::String to_string() const noexcept;
-
-    /// Addition which saturates at the maximum value.
-    ///
-    ::org::defi_wallet_core::U256
-    saturating_add(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Subtraction which saturates at zero.
-    ///
-    ::org::defi_wallet_core::U256
-    saturating_sub(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Multiplication which saturates at maximum value.
-    ///
-    ::org::defi_wallet_core::U256
-    saturating_mul(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the addition along with a boolean indicating whether an
-    /// arithmetic overflow would occur. If an overflow would have occurred then
-    /// the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_add(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the subtraction along with a boolean indicating whether an
-    /// arithmetic overflow would occur. If an overflow would have occurred then
-    /// the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_sub(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the multiplication along with a boolean indicating whether an
-    /// arithmetic overflow would occur. If an overflow would have occurred then
-    /// the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_mul(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns the fast exponentiation by squaring along with a boolean
-    /// indicating whether an arithmetic overflow would occur. If an overflow
-    /// would have occurred then the wrapped value is returned.
-    ::org::defi_wallet_core::U256WithOverflow
-    overflowing_pow(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Negates self in an overflowing fashion.
-    /// Returns !self + 1 using wrapping operations to return the value that
-    /// represents the negation of this unsigned value. Note that for positive
-    /// unsigned values overflow always occurs, but negating 0 does not
-    /// overflow.
-    ::org::defi_wallet_core::U256WithOverflow overflowing_neg() const noexcept;
-
-    /// add, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    add(::org::defi_wallet_core::U256 other) const;
-
-    /// sub, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    sub(::org::defi_wallet_core::U256 other) const;
-
-    /// mul, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    mul(::org::defi_wallet_core::U256 other) const;
-
-    /// pow, exception is rasided if overflow
-    ///
-    ::org::defi_wallet_core::U256
-    pow(::org::defi_wallet_core::U256 other) const;
-
-    /// Negates self in an overflowing fashion.
-    /// Returns !self + 1 using wrapping operations to return the value that
-    /// represents the negation of this unsigned value.
-    ::org::defi_wallet_core::U256 neg() const noexcept;
-
-    /// Returns a pair `(self / other)`
-    ///
-    ::org::defi_wallet_core::U256
-    div(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Returns a pair `(self % other)`
-    ///
-    ::org::defi_wallet_core::U256
-    rem(::org::defi_wallet_core::U256 other) const noexcept;
-
-    /// Write to the slice in big-endian format.
-    ///
-    void to_big_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
-
-    /// Write to the slice in little-endian format.
-    ///
-    void to_little_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
-
-    /// Format the output for the user which prefer to see values in ether
-    /// (instead of wei) Divides the input by 1e18
-    ::org::defi_wallet_core::U256 format_ether() const noexcept;
-
-    /// Convert to common ethereum unit types: ether, gwei, or wei
-    /// formatted in _ETH decimals_ (e.g. "1.50000...") wrapped as string
-    ::rust::String format_units(::rust::String units) const;
-
-    bool operator==(U256 const &) const noexcept;
-    bool operator!=(U256 const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  ::std::array<::std::uint64_t, 4> data;
+
+  /// Convert to Decimal String
+  ///
+  ::rust::String to_string() const noexcept;
+
+  /// Addition which saturates at the maximum value.
+  ///
+  ::org::defi_wallet_core::U256 saturating_add(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Subtraction which saturates at zero.
+  ///
+  ::org::defi_wallet_core::U256 saturating_sub(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Multiplication which saturates at maximum value.
+  ///
+  ::org::defi_wallet_core::U256 saturating_mul(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the addition along with a boolean indicating whether an arithmetic overflow
+  /// would occur. If an overflow would have occurred then the wrapped value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_add(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the subtraction along with a boolean indicating whether an arithmetic overflow
+  /// would occur. If an overflow would have occurred then the wrapped value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_sub(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the multiplication along with a boolean indicating whether an arithmetic overflow
+  /// would occur. If an overflow would have occurred then the wrapped value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_mul(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns the fast exponentiation by squaring along with a boolean indicating whether an
+  /// arithmetic overflow would occur. If an overflow would have occurred then the wrapped
+  /// value is returned.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_pow(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Negates self in an overflowing fashion.
+  /// Returns !self + 1 using wrapping operations to return the value that represents
+  /// the negation of this unsigned value. Note that for positive unsigned values
+  /// overflow always occurs, but negating 0 does not overflow.
+  ::org::defi_wallet_core::U256WithOverflow overflowing_neg() const noexcept;
+
+  /// add, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 add(::org::defi_wallet_core::U256 other) const;
+
+  /// sub, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 sub(::org::defi_wallet_core::U256 other) const;
+
+  /// mul, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 mul(::org::defi_wallet_core::U256 other) const;
+
+  /// pow, exception is rasided if overflow
+  ///
+  ::org::defi_wallet_core::U256 pow(::org::defi_wallet_core::U256 other) const;
+
+  /// Negates self in an overflowing fashion.
+  /// Returns !self + 1 using wrapping operations to return the value that represents
+  /// the negation of this unsigned value.
+  ::org::defi_wallet_core::U256 neg() const noexcept;
+
+  /// Returns a pair `(self / other)`
+  ///
+  ::org::defi_wallet_core::U256 div(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Returns a pair `(self % other)`
+  ///
+  ::org::defi_wallet_core::U256 rem(::org::defi_wallet_core::U256 other) const noexcept;
+
+  /// Write to the slice in big-endian format.
+  ///
+  void to_big_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
+
+  /// Write to the slice in little-endian format.
+  ///
+  void to_little_endian(::rust::Vec<::std::uint8_t> &bytes) const noexcept;
+
+  /// Format the output for the user which prefer to see values in ether (instead of wei)
+  /// Divides the input by 1e18
+  ::org::defi_wallet_core::U256 format_ether() const noexcept;
+
+  /// Convert to common ethereum unit types: ether, gwei, or wei
+  /// formatted in _ETH decimals_ (e.g. "1.50000...") wrapped as string
+  ::rust::String format_units(::rust::String units) const;
+
+  bool operator==(U256 const &) const noexcept;
+  bool operator!=(U256 const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256
 
 #ifndef CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256WithOverflow
 #define CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256WithOverflow
 struct U256WithOverflow final {
-    ::org::defi_wallet_core::U256 result;
-    bool overflow;
+  ::org::defi_wallet_core::U256 result;
+  bool overflow;
 
-    bool operator==(U256WithOverflow const &) const noexcept;
-    bool operator!=(U256WithOverflow const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  bool operator==(U256WithOverflow const &) const noexcept;
+  bool operator!=(U256WithOverflow const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_org$defi_wallet_core$U256WithOverflow
 
@@ -792,8 +829,8 @@ struct U256WithOverflow final {
 ///
 ::org::defi_wallet_core::U256 u256(::rust::String value);
 
-/// Converts a string slice in a given base to an integer. Only supports radixes
-/// of 10 and 16.
+/// Converts a string slice in a given base to an integer. Only supports radixes of 10
+/// and 16.
 ::org::defi_wallet_core::U256 u256(::rust::String txt, ::std::uint32_t radix);
 
 /// The maximum value which can be inhabited by this type.
@@ -806,7 +843,6 @@ ::org::defi_wallet_core::U256 parse_ether(::rust::String eth);
 
 /// Multiplies the provided amount with 10^{units} provided.
 ///
-::org::defi_wallet_core::U256 parse_units(::rust::String amount,
-                                          ::rust::String units);
+::org::defi_wallet_core::U256 parse_units(::rust::String amount, ::rust::String units);
 } // namespace defi_wallet_core
 } // namespace org
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.cc b/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.cc
index 2a3ca59a..050b9e9b 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.cc
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.cc
@@ -22,548 +22,587 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_STR
 #define CXXBRIDGE1_RUST_STR
 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;
-
-    const char *data() const noexcept;
-    std::size_t size() const noexcept;
-    std::size_t length() const noexcept;
-    bool empty() const noexcept;
-
-    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;
+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;
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  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
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
@@ -574,208 +613,236 @@ constexpr unsafe_bitcopy_t unsafe_bitcopy{};
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -785,31 +852,31 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_ERROR
 #define CXXBRIDGE1_RUST_ERROR
 class Error final : public std::exception {
-  public:
-    Error(const Error &);
-    Error(Error &&) noexcept;
-    ~Error() noexcept override;
+public:
+  Error(const Error &);
+  Error(Error &&) noexcept;
+  ~Error() noexcept override;
 
-    Error &operator=(const Error &) &;
-    Error &operator=(Error &&) &noexcept;
+  Error &operator=(const Error &) &;
+  Error &operator=(Error &&) &noexcept;
 
-    const char *what() const noexcept override;
+  const char *what() const noexcept override;
 
-  private:
-    Error() noexcept = default;
-    friend impl<Error>;
-    const char *msg;
-    std::size_t len;
+private:
+  Error() noexcept = default;
+  friend impl<Error>;
+  const char *msg;
+  std::size_t len;
 };
 #endif // CXXBRIDGE1_RUST_ERROR
 
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -828,142 +895,154 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 
 namespace repr {
 using Fat = ::std::array<::std::uintptr_t, 2>;
 
 struct PtrLen final {
-    void *ptr;
-    ::std::size_t len;
+  void *ptr;
+  ::std::size_t len;
 };
 } // namespace repr
 
 namespace detail {
-template <typename T, typename = void *> struct operator_new {
-    void *operator()(::std::size_t sz) { return ::operator new(sz); }
+template <typename T, typename = void *>
+struct operator_new {
+  void *operator()(::std::size_t sz) { return ::operator new(sz); }
 };
 
 template <typename T>
 struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
-    void *operator()(::std::size_t sz) { return T::operator new(sz); }
+  void *operator()(::std::size_t sz) { return T::operator new(sz); }
 };
 } // namespace detail
 
-template <typename T> union ManuallyDrop {
-    T value;
-    ManuallyDrop(T &&value) : value(::std::move(value)) {}
-    ~ManuallyDrop() {}
+template <typename T>
+union ManuallyDrop {
+  T value;
+  ManuallyDrop(T &&value) : value(::std::move(value)) {}
+  ~ManuallyDrop() {}
 };
 
-template <typename T> union MaybeUninit {
-    T value;
-    void *operator new(::std::size_t sz) {
-        return detail::operator_new<T>{}(sz);
-    }
-    MaybeUninit() {}
-    ~MaybeUninit() {}
+template <typename T>
+union MaybeUninit {
+  T value;
+  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
+  MaybeUninit() {}
+  ~MaybeUninit() {}
 };
 
 namespace {
-template <> class impl<Str> final {
-  public:
-    static repr::Fat repr(Str str) noexcept { return str.repr; }
+template <>
+class impl<Str> final {
+public:
+  static repr::Fat repr(Str str) noexcept {
+    return str.repr;
+  }
 };
 
-template <> class impl<Error> final {
-  public:
-    static Error error(repr::PtrLen repr) noexcept {
-        Error error;
-        error.msg = static_cast<char const *>(repr.ptr);
-        error.len = repr.len;
-        return error;
-    }
+template <>
+class impl<Error> final {
+public:
+  static Error error(repr::PtrLen repr) noexcept {
+    Error error;
+    error.msg = static_cast<char const *>(repr.ptr);
+    error.len = repr.len;
+    return error;
+  }
 };
 
 template <bool> struct deleter_if {
-    template <typename T> void operator()(T *) {}
+  template <typename T> void operator()(T *) {}
 };
 
 template <> struct deleter_if<true> {
-    template <typename T> void operator()(T *ptr) { ptr->~T(); }
+  template <typename T> void operator()(T *ptr) { ptr->~T(); }
 };
 } // namespace
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace com {
-namespace crypto {
-namespace game_sdk {
-struct WalletConnectTransactionReceiptRaw;
-using WalletConnectCallback = ::com::crypto::game_sdk::WalletConnectCallback;
-using WalletConnectSessionInfo =
-    ::com::crypto::game_sdk::WalletConnectSessionInfo;
-struct WalletEntry;
-enum class Platform : ::std::uint8_t;
-struct ImageUrl;
-struct WalletQrcode;
-struct WalletConnectTxCommon;
-struct WalletConnectTxEip155;
-struct WalletConnectAddress;
-struct WalletConnectEnsureSessionResult;
-struct WalletConnect2Eip155Accounts;
-struct WalletConnect2Eip155;
-struct WalletConnect2EnsureSessionResult;
-struct CryptoComPaymentResponse;
-struct RawTxDetail;
-struct RawTokenResult;
-struct TokenHolderDetail;
-enum class QueryOption : ::std::uint8_t;
-struct WalletconnectClient;
-struct Walletconnect2Client;
-using OptionalArguments = ::com::crypto::game_sdk::OptionalArguments;
-} // namespace game_sdk
-} // namespace crypto
-} // namespace com
+  namespace crypto {
+    namespace game_sdk {
+      struct WalletConnectTransactionReceiptRaw;
+      using WalletConnectCallback = ::com::crypto::game_sdk::WalletConnectCallback;
+      using WalletConnectSessionInfo = ::com::crypto::game_sdk::WalletConnectSessionInfo;
+      struct WalletEntry;
+      enum class Platform : ::std::uint8_t;
+      struct ImageUrl;
+      struct WalletQrcode;
+      struct WalletConnectTxCommon;
+      struct WalletConnectTxEip155;
+      struct WalletConnectAddress;
+      struct WalletConnectEnsureSessionResult;
+      struct WalletConnect2Eip155Accounts;
+      struct WalletConnect2Eip155;
+      struct WalletConnect2EnsureSessionResult;
+      struct CryptoComPaymentResponse;
+      struct RawTxDetail;
+      struct RawTokenResult;
+      struct TokenHolderDetail;
+      enum class QueryOption : ::std::uint8_t;
+      struct WalletconnectClient;
+      struct Walletconnect2Client;
+      using OptionalArguments = ::com::crypto::game_sdk::OptionalArguments;
+    }
+  }
+}
 
 namespace com {
 namespace crypto {
@@ -971,23 +1050,23 @@ namespace game_sdk {
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTransactionReceiptRaw
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTransactionReceiptRaw
 struct WalletConnectTransactionReceiptRaw final {
-    ::rust::Vec<::std::uint8_t> transaction_hash;
-    ::rust::String transaction_index;
-    ::rust::Vec<::std::uint8_t> block_hash;
-    ::rust::String block_number;
-    ::rust::String cumulative_gas_used;
-    ::rust::String gas_used;
-    ::rust::String contract_address;
-    ::rust::Vec<::rust::String> logs;
-    /// Status: either 1 (success) or 0 (failure)
-    ///
-    ::rust::String status;
-    ::rust::Vec<::std::uint8_t> root;
-    ::rust::Vec<::std::uint8_t> logs_bloom;
-    ::rust::String transaction_type;
-    ::rust::String effective_gas_price;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::Vec<::std::uint8_t> transaction_hash;
+  ::rust::String transaction_index;
+  ::rust::Vec<::std::uint8_t> block_hash;
+  ::rust::String block_number;
+  ::rust::String cumulative_gas_used;
+  ::rust::String gas_used;
+  ::rust::String contract_address;
+  ::rust::Vec<::rust::String> logs;
+  /// Status: either 1 (success) or 0 (failure)
+  ///
+  ::rust::String status;
+  ::rust::Vec<::std::uint8_t> root;
+  ::rust::Vec<::std::uint8_t> logs_bloom;
+  ::rust::String transaction_type;
+  ::rust::String effective_gas_price;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTransactionReceiptRaw
 
@@ -996,17 +1075,17 @@ struct WalletConnectTransactionReceiptRaw final {
 /// The icon URLs
 ///
 struct ImageUrl final {
-    /// small
-    ///
-    ::rust::String sm;
-    /// medium
-    ///
-    ::rust::String md;
-    /// large
-    ///
-    ::rust::String lg;
-
-    using IsRelocatable = ::std::true_type;
+  /// small
+  ///
+  ::rust::String sm;
+  /// medium
+  ///
+  ::rust::String md;
+  /// large
+  ///
+  ::rust::String lg;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$ImageUrl
 
@@ -1015,29 +1094,29 @@ struct ImageUrl final {
 /// The wallet registry entry
 ///
 struct WalletEntry final {
-    /// wallet id
-    ///
-    ::rust::String id;
-    /// its name
-    ///
-    ::rust::String name;
-    /// icon URLs
-    ///
-    ::com::crypto::game_sdk::ImageUrl image_url;
-    /// mobile native link, empty if none
-    ///
-    ::rust::String mobile_native_link;
-    /// mobile universal link, empty if none
-    ///
-    ::rust::String mobile_universal_link;
-    /// desktop native link, empty if none
-    ///
-    ::rust::String desktop_native_link;
-    /// desktop universal link, empty if none
-    ///
-    ::rust::String desktop_universal_link;
-
-    using IsRelocatable = ::std::true_type;
+  /// wallet id
+  ///
+  ::rust::String id;
+  /// its name
+  ///
+  ::rust::String name;
+  /// icon URLs
+  ///
+  ::com::crypto::game_sdk::ImageUrl image_url;
+  /// mobile native link, empty if none
+  ///
+  ::rust::String mobile_native_link;
+  /// mobile universal link, empty if none
+  ///
+  ::rust::String mobile_universal_link;
+  /// desktop native link, empty if none
+  ///
+  ::rust::String desktop_native_link;
+  /// desktop universal link, empty if none
+  ///
+  ::rust::String desktop_universal_link;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletEntry
 
@@ -1046,32 +1125,32 @@ struct WalletEntry final {
 /// The target platform
 ///
 enum class Platform : ::std::uint8_t {
-    Mobile = 0,
-    Desktop = 1,
+  Mobile = 0,
+  Desktop = 1,
 };
 #endif // CXXBRIDGE1_ENUM_com$crypto$game_sdk$Platform
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletQrcode
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletQrcode
 struct WalletQrcode final {
-    ::rust::String qrcode;
-    ::rust::Vec<::std::uint8_t> image;
-    ::std::uint32_t size;
+  ::rust::String qrcode;
+  ::rust::Vec<::std::uint8_t> image;
+  ::std::uint32_t size;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletQrcode
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxCommon
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxCommon
 struct WalletConnectTxCommon final {
-    ::rust::String gas_limit;
-    ::rust::String gas_price;
-    ::rust::String nonce;
-    ::std::uint64_t chainid;
-    ::rust::String web3api_url;
+  ::rust::String gas_limit;
+  ::rust::String gas_price;
+  ::rust::String nonce;
+  ::std::uint64_t chainid;
+  ::rust::String web3api_url;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxCommon
 
@@ -1080,12 +1159,13 @@ struct WalletConnectTxCommon final {
 /// wallet connect cronos(eth) eip155-tx signing info
 ///
 struct WalletConnectTxEip155 final {
-    ::rust::String to;
-    ::rust::String value;
-    ::rust::Vec<::std::uint8_t> data;
-    ::com::crypto::game_sdk::WalletConnectTxCommon common;
+  ::rust::String from;
+  ::rust::String to;
+  ::rust::String value;
+  ::rust::Vec<::std::uint8_t> data;
+  ::com::crypto::game_sdk::WalletConnectTxCommon common;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxEip155
 
@@ -1094,9 +1174,9 @@ struct WalletConnectTxEip155 final {
 /// cronos address info
 ///
 struct WalletConnectAddress final {
-    ::std::array<::std::uint8_t, 20> address;
+  ::std::array<::std::uint8_t, 20> address;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectAddress
 
@@ -1105,40 +1185,40 @@ struct WalletConnectAddress final {
 /// walletconnect ensure-session result
 ///
 struct WalletConnectEnsureSessionResult final {
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> addresses;
-    ::std::uint64_t chain_id;
+  ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> addresses;
+  ::std::uint64_t chain_id;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectEnsureSessionResult
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155Accounts
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155Accounts
 struct WalletConnect2Eip155Accounts final {
-    ::com::crypto::game_sdk::WalletConnectAddress address;
-    ::std::uint64_t chain_id;
+  ::com::crypto::game_sdk::WalletConnectAddress address;
+  ::std::uint64_t chain_id;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155Accounts
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155
 struct WalletConnect2Eip155 final {
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> accounts;
-    ::rust::Vec<::rust::String> methods;
-    ::rust::Vec<::rust::String> events;
+  ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> accounts;
+  ::rust::Vec<::rust::String> methods;
+  ::rust::Vec<::rust::String> events;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2EnsureSessionResult
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2EnsureSessionResult
 struct WalletConnect2EnsureSessionResult final {
-    ::com::crypto::game_sdk::WalletConnect2Eip155 eip155;
+  ::com::crypto::game_sdk::WalletConnect2Eip155 eip155;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2EnsureSessionResult
 
@@ -1147,64 +1227,63 @@ struct WalletConnect2EnsureSessionResult final {
 /// the subset of payment object from https://pay-docs.crypto.com
 ///
 struct CryptoComPaymentResponse final {
-    /// uuid of the payment object
-    ///
-    ::rust::String id;
-    /// the base64 payload to be displayed as QR code that
-    /// can be scanned by the main app
-    ::rust::String main_app_qr_code;
-    /// if the on-chain payment is desired, this will
-    /// have the cryptocurrency address that can be displayed
-    /// as a QR code or put in a tx to be signed via WalletConnect
-    ::rust::String onchain_deposit_address;
-    /// the amount in base denomination
-    /// e.g. for USD, it's cents (1 USD == 100 cents)
-    ::rust::String base_amount;
-    /// the 3-letter currency code
-    ///
-    ::rust::String currency;
-    /// expiration time in unix timestamp (10 minutes)
-    ///
-    ::std::uint64_t expiration;
-    /// the status of the payment
-    ///
-    ::rust::String status;
-
-    using IsRelocatable = ::std::true_type;
+  /// uuid of the payment object
+  ///
+  ::rust::String id;
+  /// the base64 payload to be displayed as QR code that
+  /// can be scanned by the main app
+  ::rust::String main_app_qr_code;
+  /// if the on-chain payment is desired, this will
+  /// have the cryptocurrency address that can be displayed
+  /// as a QR code or put in a tx to be signed via WalletConnect
+  ::rust::String onchain_deposit_address;
+  /// the amount in base denomination
+  /// e.g. for USD, it's cents (1 USD == 100 cents)
+  ::rust::String base_amount;
+  /// the 3-letter currency code
+  ///
+  ::rust::String currency;
+  /// expiration time in unix timestamp (10 minutes)
+  ///
+  ::std::uint64_t expiration;
+  /// the status of the payment
+  ///
+  ::rust::String status;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$CryptoComPaymentResponse
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTxDetail
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTxDetail
-/// Raw transaction details (extracted from Cronoscan/Etherscan or BlockScout
-/// API)
+/// Raw transaction details (extracted from Cronoscan/Etherscan or BlockScout API)
 ///
 struct RawTxDetail final {
-    /// Transaction hash
-    ///
-    ::rust::String hash;
-    /// the hexadecimal address of the receiver
-    ///
-    ::rust::String to_address;
-    /// the hexadecimal address of the sender
-    ///
-    ::rust::String from_address;
-    /// the value sent in decimal (in base tokens)
-    ///
-    ::rust::String value;
-    /// block number when it happened
-    ///
-    ::std::uint64_t block_no;
-    /// the time it happened
-    ///
-    ::rust::String timestamp;
-    /// the address of the contract (if no contract, it's an empty string)
-    ///
-    ::rust::String contract_address;
-
-    bool operator==(RawTxDetail const &) const noexcept;
-    bool operator!=(RawTxDetail const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  /// Transaction hash
+  ///
+  ::rust::String hash;
+  /// the hexadecimal address of the receiver
+  ///
+  ::rust::String to_address;
+  /// the hexadecimal address of the sender
+  ///
+  ::rust::String from_address;
+  /// the value sent in decimal (in base tokens)
+  ///
+  ::rust::String value;
+  /// block number when it happened
+  ///
+  ::std::uint64_t block_no;
+  /// the time it happened
+  ///
+  ::rust::String timestamp;
+  /// the address of the contract (if no contract, it's an empty string)
+  ///
+  ::rust::String contract_address;
+
+  bool operator==(RawTxDetail const &) const noexcept;
+  bool operator!=(RawTxDetail const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTxDetail
 
@@ -1213,31 +1292,31 @@ struct RawTxDetail final {
 /// Token ownership result detail from BlockScout API
 ///
 struct RawTokenResult final {
-    /// how many tokens are owned by the address
-    ///
-    ::rust::String balance;
-    /// the deployed contract address
-    ///
-    ::rust::String contract_address;
-    /// the number of decimal places
-    ///
-    ::rust::String decimals;
-    /// the token id
-    ///
-    ::rust::String id;
-    /// the human-readable name of the token
-    ///
-    ::rust::String name;
-    /// the ticker for the token
-    ///
-    ::rust::String symbol;
-    /// the token type (ERC-20, ERC-721, ERC-1155)
-    ///
-    ::rust::String token_type;
-
-    bool operator==(RawTokenResult const &) const noexcept;
-    bool operator!=(RawTokenResult const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  /// how many tokens are owned by the address
+  ///
+  ::rust::String balance;
+  /// the deployed contract address
+  ///
+  ::rust::String contract_address;
+  /// the number of decimal places
+  ///
+  ::rust::String decimals;
+  /// the token id
+  ///
+  ::rust::String id;
+  /// the human-readable name of the token
+  ///
+  ::rust::String name;
+  /// the ticker for the token
+  ///
+  ::rust::String symbol;
+  /// the token type (ERC-20, ERC-721, ERC-1155)
+  ///
+  ::rust::String token_type;
+
+  bool operator==(RawTokenResult const &) const noexcept;
+  bool operator!=(RawTokenResult const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTokenResult
 
@@ -1247,25 +1326,25 @@ struct RawTokenResult final {
 ///
 /// tokenid is not supported yet.
 struct TokenHolderDetail final {
-    /// the holder address
-    ///
-    ::rust::String address;
-    /// balance of the target token
-    ///
-    ::rust::String value;
-
-    bool operator==(TokenHolderDetail const &) const noexcept;
-    bool operator!=(TokenHolderDetail const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  /// the holder address
+  ///
+  ::rust::String address;
+  /// balance of the target token
+  ///
+  ::rust::String value;
+
+  bool operator==(TokenHolderDetail const &) const noexcept;
+  bool operator!=(TokenHolderDetail const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$TokenHolderDetail
 
 #ifndef CXXBRIDGE1_ENUM_com$crypto$game_sdk$QueryOption
 #define CXXBRIDGE1_ENUM_com$crypto$game_sdk$QueryOption
 enum class QueryOption : ::std::uint8_t {
-    ByContract = 0,
-    ByAddressAndContract = 1,
-    ByAddress = 2,
+  ByContract = 0,
+  ByAddressAndContract = 1,
+  ByAddress = 2,
 };
 #endif // CXXBRIDGE1_ENUM_com$crypto$game_sdk$QueryOption
 
@@ -1274,1844 +1353,1128 @@ enum class QueryOption : ::std::uint8_t {
 /// WallnetConnect API
 ///
 struct WalletconnectClient final : public ::rust::Opaque {
-    /// setup callback
-    ///
-    void setup_callback_blocking(
-        ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>
-            usercallback);
-
-    /// create or restore a session
-    /// once session is created, it will be reused
-    ::com::crypto::game_sdk::WalletConnectEnsureSessionResult
-    ensure_session_blocking();
-
-    /// get connection string for qrcode
-    ///
-    ::rust::String get_connection_string();
-
-    /// write session-info to string, which can be written to file
-    ///
-    ::rust::String save_client();
-
-    /// print qrcode in termal, for debugging
-    ///
-    ::rust::String print_uri();
-
-    /// sign message
-    ///
-    ::rust::Vec<::std::uint8_t>
-    sign_personal_blocking(::rust::String message,
-                           ::std::array<::std::uint8_t, 20> address);
-
-    /// build cronos(eth) eip155 transaction
-    /// Supported Wallets: Trust Wallet, Crypto.com Desktop Defi Wallet
-    ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-
-    /// send cronos(eth) eip155 transaction
-    /// Supported Wallets: Trust Wallet, MetaMask and Crypto.com Mobile Defi
-    /// Wallet
-    ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-
-    /// eip1559_transaction_request: json string of Eip1559TransactionRequest
-    /// return signed transaction bytes
-    ::rust::Vec<::std::uint8_t>
-    sign_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-
-    /// eip1559_transaction_request: json string of Eip1559TransactionRequest
-    /// return transaction hash bytes
-    ::rust::Vec<::std::uint8_t>
-    send_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-
-    /// sign a contract transaction
-    /// contract_action is a json string of `ContractAction` type, for example:
-    /// for example, transfer Erc20 token
-    /// {
-    ///     "ContractTransfer": {
-    ///         "Erc20Transfer": {
-    ///             "contract_address": "0xxxxx",
-    ///             "to_address": "0xxxxx",
-    ///             "amount": "1000000000000000000"
-    ///         }
-    ///     }
-    /// }
-    /// return signed transaction bytes
-    ::rust::Vec<::std::uint8_t> sign_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-
-    /// contract_action is a json string of `ContractAction` type
-    /// for example, transfer Erc20 token
-    /// {
-    ///     "ContractTransfer": {
-    ///         "Erc20Transfer": {
-    ///             "contract_address": "0xxxxx",
-    ///             "to_address": "0xxxxx",
-    ///             "amount": "1000000000000000000"
-    ///         }
-    ///     }
-    /// }
-    ::rust::Vec<::std::uint8_t> send_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-
-    ~WalletconnectClient() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// setup callback
+  ///
+  void setup_callback_blocking(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> usercallback);
+
+  /// create or restore a session
+  /// once session is created, it will be reused
+  ::com::crypto::game_sdk::WalletConnectEnsureSessionResult ensure_session_blocking();
+
+  /// get connection string for qrcode
+  ///
+  ::rust::String get_connection_string();
+
+  /// write session-info to string, which can be written to file
+  ///
+  ::rust::String save_client();
+
+  /// print qrcode in termal, for debugging
+  ///
+  ::rust::String print_uri();
+
+  /// sign message
+  ///
+  ::rust::Vec<::std::uint8_t> sign_personal_blocking(::rust::String message, ::std::array<::std::uint8_t, 20> address);
+
+  /// build cronos(eth) eip155 transaction
+  /// Supported Wallets: Trust Wallet, Crypto.com Desktop Defi Wallet
+  ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+
+  /// send cronos(eth) eip155 transaction
+  /// Supported Wallets: Trust Wallet, MetaMask and Crypto.com Mobile Defi Wallet
+  ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+
+  /// eip1559_transaction_request: json string of Eip1559TransactionRequest
+  /// return signed transaction bytes
+  ::rust::Vec<::std::uint8_t> sign_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+
+  /// eip1559_transaction_request: json string of Eip1559TransactionRequest
+  /// return transaction hash bytes
+  ::rust::Vec<::std::uint8_t> send_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+
+  /// sign a contract transaction
+  /// contract_action is a json string of `ContractAction` type, for example:
+  /// for example, transfer Erc20 token
+  /// {
+  ///     "ContractTransfer": {
+  ///         "Erc20Transfer": {
+  ///             "contract_address": "0xxxxx",
+  ///             "to_address": "0xxxxx",
+  ///             "amount": "1000000000000000000"
+  ///         }
+  ///     }
+  /// }
+  /// return signed transaction bytes
+  ::rust::Vec<::std::uint8_t> sign_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+
+  /// contract_action is a json string of `ContractAction` type
+  /// for example, transfer Erc20 token
+  /// {
+  ///     "ContractTransfer": {
+  ///         "Erc20Transfer": {
+  ///             "contract_address": "0xxxxx",
+  ///             "to_address": "0xxxxx",
+  ///             "amount": "1000000000000000000"
+  ///         }
+  ///     }
+  /// }
+  ::rust::Vec<::std::uint8_t> send_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+
+  ~WalletconnectClient() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletconnectClient
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$Walletconnect2Client
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$Walletconnect2Client
 struct Walletconnect2Client final : public ::rust::Opaque {
-    ::com::crypto::game_sdk::WalletConnect2EnsureSessionResult
-    ensure_session_blocking(::std::uint64_t waitmillis);
-    ::rust::String poll_events_blocking(::std::uint64_t waitmillis);
-    ::rust::String get_connection_string();
-    ::rust::String save_client();
-    ::rust::String print_uri();
-    ::rust::Vec<::std::uint8_t>
-    sign_personal_blocking(::rust::String message,
-                           ::std::array<::std::uint8_t, 20> address);
-    ::rust::String ping_blocking(::std::uint64_t waitmillis);
-    ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t>
-    sign_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t>
-    send_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t> sign_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t> send_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-    ~Walletconnect2Client() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ::com::crypto::game_sdk::WalletConnect2EnsureSessionResult ensure_session_blocking(::std::uint64_t waitmillis);
+  ::rust::String poll_events_blocking(::std::uint64_t waitmillis);
+  ::rust::String get_connection_string();
+  ::rust::String save_client();
+  ::rust::String print_uri();
+  ::rust::Vec<::std::uint8_t> sign_personal_blocking(::rust::String message, ::std::array<::std::uint8_t, 20> address);
+  ::rust::String ping_blocking(::std::uint64_t waitmillis);
+  ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> sign_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> send_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> sign_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> send_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+  ~Walletconnect2Client() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$Walletconnect2Client
 
 extern "C" {
-void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onConnected(
-    ::com::crypto::game_sdk::WalletConnectCallback const &self,
-    ::com::crypto::game_sdk::WalletConnectSessionInfo const
-        &sessioninfo) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectCallback::*onConnected$)(
-        ::com::crypto::game_sdk::WalletConnectSessionInfo const &) const =
-        &::com::crypto::game_sdk::WalletConnectCallback::onConnected;
-    (self.*onConnected$)(sessioninfo);
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onDisconnected(
-    ::com::crypto::game_sdk::WalletConnectCallback const &self,
-    ::com::crypto::game_sdk::WalletConnectSessionInfo const
-        &sessioninfo) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectCallback::*onDisconnected$)(
-        ::com::crypto::game_sdk::WalletConnectSessionInfo const &) const =
-        &::com::crypto::game_sdk::WalletConnectCallback::onDisconnected;
-    (self.*onDisconnected$)(sessioninfo);
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onConnecting(
-    ::com::crypto::game_sdk::WalletConnectCallback const &self,
-    ::com::crypto::game_sdk::WalletConnectSessionInfo const
-        &sessioninfo) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectCallback::*onConnecting$)(
-        ::com::crypto::game_sdk::WalletConnectSessionInfo const &) const =
-        &::com::crypto::game_sdk::WalletConnectCallback::onConnecting;
-    (self.*onConnecting$)(sessioninfo);
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onUpdated(
-    ::com::crypto::game_sdk::WalletConnectCallback const &self,
-    ::com::crypto::game_sdk::WalletConnectSessionInfo const
-        &sessioninfo) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectCallback::*onUpdated$)(
-        ::com::crypto::game_sdk::WalletConnectSessionInfo const &) const =
-        &::com::crypto::game_sdk::WalletConnectCallback::onUpdated;
-    (self.*onUpdated$)(sessioninfo);
-}
-
-::com::crypto::game_sdk::WalletConnectSessionInfo *
-com$crypto$game_sdk$cxxbridge1$new_walletconnect_sessioninfo() noexcept {
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> (
-        *new_walletconnect_sessioninfo$)() =
-        ::com::crypto::game_sdk::new_walletconnect_sessioninfo;
-    return new_walletconnect_sessioninfo$().release();
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_chainid(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *chainid) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_chainid$)(
-        ::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_chainid;
-    (self.*set_chainid$)(::rust::String(::rust::unsafe_bitcopy, *chainid));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_connected(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    bool connected) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_connected$)(
-        bool) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_connected;
-    (self.*set_connected$)(connected);
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_accounts(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::Vec<::rust::String> const *accounts) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_accounts$)(
-        ::rust::Vec<::rust::String>) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_accounts;
-    (self.*set_accounts$)(
-        ::rust::Vec<::rust::String>(::rust::unsafe_bitcopy, *accounts));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_bridge(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *bridge) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_bridge$)(
-        ::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_bridge;
-    (self.*set_bridge$)(::rust::String(::rust::unsafe_bitcopy, *bridge));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_key(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *key) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_key$)(
-        ::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_key;
-    (self.*set_key$)(::rust::String(::rust::unsafe_bitcopy, *key));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_clientid(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *clientid) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_clientid$)(
-        ::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_clientid;
-    (self.*set_clientid$)(::rust::String(::rust::unsafe_bitcopy, *clientid));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_clientmeta(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *clientmeta) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_clientmeta$)(
-        ::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_clientmeta;
-    (self.*
-     set_clientmeta$)(::rust::String(::rust::unsafe_bitcopy, *clientmeta));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_peerid(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *peerid) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_peerid$)(
-        ::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_peerid;
-    (self.*set_peerid$)(::rust::String(::rust::unsafe_bitcopy, *peerid));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_peermeta(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *peermeta) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_peermeta$)(
-        ::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_peermeta;
-    (self.*set_peermeta$)(::rust::String(::rust::unsafe_bitcopy, *peermeta));
-}
-
-void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_handshaketopic(
-    ::com::crypto::game_sdk::WalletConnectSessionInfo &self,
-    ::rust::String const *handshaketopic) noexcept {
-    void (::com::crypto::game_sdk::WalletConnectSessionInfo::*
-              set_handshaketopic$)(::rust::String) =
-        &::com::crypto::game_sdk::WalletConnectSessionInfo::set_handshaketopic;
-    (self.*set_handshaketopic$)(
-        ::rust::String(::rust::unsafe_bitcopy, *handshaketopic));
-}
-bool com$crypto$game_sdk$cxxbridge1$RawTxDetail$operator$eq(
-    RawTxDetail const &, RawTxDetail const &) noexcept;
-bool com$crypto$game_sdk$cxxbridge1$RawTokenResult$operator$eq(
-    RawTokenResult const &, RawTokenResult const &) noexcept;
-bool com$crypto$game_sdk$cxxbridge1$TokenHolderDetail$operator$eq(
-    TokenHolderDetail const &, TokenHolderDetail const &) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$filter_wallets(
-    bool cached, ::rust::String *registry_local_path,
-    ::com::crypto::game_sdk::Platform platform,
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_all_wallets(
-    bool cached, ::rust::String *registry_local_path,
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$check_wallet(
-    bool cached, ::rust::String *registry_local_path, ::rust::String *id,
-    ::com::crypto::game_sdk::Platform platform, bool *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_wallet(
-    bool cached, ::rust::String *registry_local_path, ::rust::String *id,
-    ::com::crypto::game_sdk::WalletEntry *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$generate_qrcode(
-    ::rust::String *qrcodestring,
-    ::com::crypto::game_sdk::WalletQrcode *return$) noexcept;
-::std::size_t
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$sizeof() noexcept;
-::std::size_t
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$alignof() noexcept;
-::std::size_t
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$sizeof() noexcept;
-::std::size_t
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$alignof() noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$walletconnect_restore_client(
-    ::rust::String *session_info,
-    ::rust::Box<::com::crypto::game_sdk::WalletconnectClient>
-        *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$walletconnect2_restore_client(
-    ::rust::String *session_info,
-    ::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>
-        *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$walletconnect_new_client(
-    ::rust::String *description, ::rust::String *url,
-    ::rust::Vec<::rust::String> *icon_urls, ::rust::String *name,
-    ::std::uint64_t chain_id,
-    ::rust::Box<::com::crypto::game_sdk::WalletconnectClient>
-        *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$walletconnect2_client_new(
-    ::rust::String *relayserver, ::rust::String *project_id,
-    ::rust::String *required_namespaces, ::rust::String *client_meta,
-    ::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>
-        *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$setup_callback_blocking(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::com::crypto::game_sdk::WalletConnectCallback *usercallback) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$ensure_session_blocking(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::com::crypto::game_sdk::WalletConnectEnsureSessionResult
-        *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ensure_session_blocking(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::std::uint64_t waitmillis,
-    ::com::crypto::game_sdk::WalletConnect2EnsureSessionResult
-        *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$poll_events_blocking(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::std::uint64_t waitmillis, ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$get_connection_string(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$get_connection_string(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$save_client(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$save_client(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$print_uri(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$print_uri(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_personal_blocking(
-    ::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *message,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_personal_blocking(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *message, ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ping_blocking(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::std::uint64_t waitmillis, ::rust::String *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_transaction(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::rust::String *eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_transaction(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_transaction(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::rust::String *eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_transaction(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_contract_transaction(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::rust::String *contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_contract_transaction(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_contract_transaction(
-    ::com::crypto::game_sdk::WalletconnectClient &self,
-    ::rust::String *contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_contract_transaction(
-    ::com::crypto::game_sdk::Walletconnect2Client &self,
-    ::rust::String *contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> *address,
-    ::rust::Vec<::std::uint8_t> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$get_transaction_history_blocking(
-    ::rust::String *address, ::rust::String *api_key,
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$get_erc20_transfer_history_blocking(
-    ::rust::String *address, ::rust::String *contract_address,
-    ::com::crypto::game_sdk::QueryOption option, ::rust::String *api_key,
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$get_erc721_transfer_history_blocking(
-    ::rust::String *address, ::rust::String *contract_address,
-    ::com::crypto::game_sdk::QueryOption option, ::rust::String *api_key,
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_tokens_blocking(
-    ::rust::String *blockscout_base_url, ::rust::String *account_address,
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *return$) noexcept;
-
-::rust::repr::PtrLen
-com$crypto$game_sdk$cxxbridge1$get_token_transfers_blocking(
-    ::rust::String *blockscout_base_url, ::rust::String *address,
-    ::rust::String *contract_address,
-    ::com::crypto::game_sdk::QueryOption option,
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_token_holders(
-    ::rust::String *blockscout_base_url, ::rust::String *contract_address,
-    ::std::uint64_t page, ::std::uint64_t offset,
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$create_payment(
-    ::rust::String *secret_or_publishable_api_key,
-    ::rust::String *base_unit_amount, ::rust::String *currency,
-    ::com::crypto::game_sdk::OptionalArguments const &optional_args,
-    ::com::crypto::game_sdk::CryptoComPaymentResponse *return$) noexcept;
-
-::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_payment(
-    ::rust::String *secret_or_publishable_api_key, ::rust::String *payment_id,
-    ::com::crypto::game_sdk::CryptoComPaymentResponse *return$) noexcept;
-
-::rust::repr::Fat
-com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_description(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    ::rust::Str (
-        ::com::crypto::game_sdk::OptionalArguments::*get_description$)() const =
-        &::com::crypto::game_sdk::OptionalArguments::get_description;
-    return ::rust::impl<::rust::Str>::repr((self.*get_description$)());
-}
-
-::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_metadata(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_metadata$)()
-        const = &::com::crypto::game_sdk::OptionalArguments::get_metadata;
-    return ::rust::impl<::rust::Str>::repr((self.*get_metadata$)());
-}
-
-::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_order_id(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_order_id$)()
-        const = &::com::crypto::game_sdk::OptionalArguments::get_order_id;
-    return ::rust::impl<::rust::Str>::repr((self.*get_order_id$)());
-}
-
-::rust::repr::Fat
-com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_return_url(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_return_url$)()
-        const = &::com::crypto::game_sdk::OptionalArguments::get_return_url;
-    return ::rust::impl<::rust::Str>::repr((self.*get_return_url$)());
-}
-
-::rust::repr::Fat
-com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_cancel_url(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_cancel_url$)()
-        const = &::com::crypto::game_sdk::OptionalArguments::get_cancel_url;
-    return ::rust::impl<::rust::Str>::repr((self.*get_cancel_url$)());
-}
-
-::rust::repr::Fat
-com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_sub_merchant_id(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    ::rust::Str (
-        ::com::crypto::game_sdk::OptionalArguments::*get_sub_merchant_id$)()
-        const =
-            &::com::crypto::game_sdk::OptionalArguments::get_sub_merchant_id;
-    return ::rust::impl<::rust::Str>::repr((self.*get_sub_merchant_id$)());
-}
-
-bool com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_onchain_allowed(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    bool (::com::crypto::game_sdk::OptionalArguments::*get_onchain_allowed$)()
-        const =
-            &::com::crypto::game_sdk::OptionalArguments::get_onchain_allowed;
-    return (self.*get_onchain_allowed$)();
-}
-
-::std::uint64_t com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_expired_at(
-    ::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
-    ::std::uint64_t (
-        ::com::crypto::game_sdk::OptionalArguments::*get_expired_at$)() const =
-        &::com::crypto::game_sdk::OptionalArguments::get_expired_at;
-    return (self.*get_expired_at$)();
+void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onConnected(::com::crypto::game_sdk::WalletConnectCallback const &self, ::com::crypto::game_sdk::WalletConnectSessionInfo const &sessioninfo) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectCallback::*onConnected$)(::com::crypto::game_sdk::WalletConnectSessionInfo const &) const = &::com::crypto::game_sdk::WalletConnectCallback::onConnected;
+  (self.*onConnected$)(sessioninfo);
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onDisconnected(::com::crypto::game_sdk::WalletConnectCallback const &self, ::com::crypto::game_sdk::WalletConnectSessionInfo const &sessioninfo) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectCallback::*onDisconnected$)(::com::crypto::game_sdk::WalletConnectSessionInfo const &) const = &::com::crypto::game_sdk::WalletConnectCallback::onDisconnected;
+  (self.*onDisconnected$)(sessioninfo);
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onConnecting(::com::crypto::game_sdk::WalletConnectCallback const &self, ::com::crypto::game_sdk::WalletConnectSessionInfo const &sessioninfo) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectCallback::*onConnecting$)(::com::crypto::game_sdk::WalletConnectSessionInfo const &) const = &::com::crypto::game_sdk::WalletConnectCallback::onConnecting;
+  (self.*onConnecting$)(sessioninfo);
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectCallback$onUpdated(::com::crypto::game_sdk::WalletConnectCallback const &self, ::com::crypto::game_sdk::WalletConnectSessionInfo const &sessioninfo) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectCallback::*onUpdated$)(::com::crypto::game_sdk::WalletConnectSessionInfo const &) const = &::com::crypto::game_sdk::WalletConnectCallback::onUpdated;
+  (self.*onUpdated$)(sessioninfo);
+}
+
+::com::crypto::game_sdk::WalletConnectSessionInfo *com$crypto$game_sdk$cxxbridge1$new_walletconnect_sessioninfo() noexcept {
+  ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> (*new_walletconnect_sessioninfo$)() = ::com::crypto::game_sdk::new_walletconnect_sessioninfo;
+  return new_walletconnect_sessioninfo$().release();
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_chainid(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *chainid) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_chainid$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_chainid;
+  (self.*set_chainid$)(::rust::String(::rust::unsafe_bitcopy, *chainid));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_connected(::com::crypto::game_sdk::WalletConnectSessionInfo &self, bool connected) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_connected$)(bool) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_connected;
+  (self.*set_connected$)(connected);
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_accounts(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::Vec<::rust::String> const *accounts) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_accounts$)(::rust::Vec<::rust::String>) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_accounts;
+  (self.*set_accounts$)(::rust::Vec<::rust::String>(::rust::unsafe_bitcopy, *accounts));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_bridge(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *bridge) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_bridge$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_bridge;
+  (self.*set_bridge$)(::rust::String(::rust::unsafe_bitcopy, *bridge));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_key(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *key) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_key$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_key;
+  (self.*set_key$)(::rust::String(::rust::unsafe_bitcopy, *key));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_clientid(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *clientid) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_clientid$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_clientid;
+  (self.*set_clientid$)(::rust::String(::rust::unsafe_bitcopy, *clientid));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_clientmeta(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *clientmeta) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_clientmeta$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_clientmeta;
+  (self.*set_clientmeta$)(::rust::String(::rust::unsafe_bitcopy, *clientmeta));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_peerid(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *peerid) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_peerid$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_peerid;
+  (self.*set_peerid$)(::rust::String(::rust::unsafe_bitcopy, *peerid));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_peermeta(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *peermeta) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_peermeta$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_peermeta;
+  (self.*set_peermeta$)(::rust::String(::rust::unsafe_bitcopy, *peermeta));
+}
+
+void com$crypto$game_sdk$cxxbridge1$WalletConnectSessionInfo$set_handshaketopic(::com::crypto::game_sdk::WalletConnectSessionInfo &self, ::rust::String const *handshaketopic) noexcept {
+  void (::com::crypto::game_sdk::WalletConnectSessionInfo::*set_handshaketopic$)(::rust::String) = &::com::crypto::game_sdk::WalletConnectSessionInfo::set_handshaketopic;
+  (self.*set_handshaketopic$)(::rust::String(::rust::unsafe_bitcopy, *handshaketopic));
+}
+bool com$crypto$game_sdk$cxxbridge1$RawTxDetail$operator$eq(RawTxDetail const &, RawTxDetail const &) noexcept;
+bool com$crypto$game_sdk$cxxbridge1$RawTokenResult$operator$eq(RawTokenResult const &, RawTokenResult const &) noexcept;
+bool com$crypto$game_sdk$cxxbridge1$TokenHolderDetail$operator$eq(TokenHolderDetail const &, TokenHolderDetail const &) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$filter_wallets(bool cached, ::rust::String *registry_local_path, ::com::crypto::game_sdk::Platform platform, ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_all_wallets(bool cached, ::rust::String *registry_local_path, ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$check_wallet(bool cached, ::rust::String *registry_local_path, ::rust::String *id, ::com::crypto::game_sdk::Platform platform, bool *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_wallet(bool cached, ::rust::String *registry_local_path, ::rust::String *id, ::com::crypto::game_sdk::WalletEntry *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$generate_qrcode(::rust::String *qrcodestring, ::com::crypto::game_sdk::WalletQrcode *return$) noexcept;
+::std::size_t com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$sizeof() noexcept;
+::std::size_t com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$alignof() noexcept;
+::std::size_t com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$sizeof() noexcept;
+::std::size_t com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$alignof() noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$walletconnect_restore_client(::rust::String *session_info, ::rust::Box<::com::crypto::game_sdk::WalletconnectClient> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$walletconnect2_restore_client(::rust::String *session_info, ::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$walletconnect_new_client(::rust::String *description, ::rust::String *url, ::rust::Vec<::rust::String> *icon_urls, ::rust::String *name, ::std::uint64_t chain_id, ::rust::Box<::com::crypto::game_sdk::WalletconnectClient> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$walletconnect2_client_new(::rust::String *relayserver, ::rust::String *project_id, ::rust::String *required_namespaces, ::rust::String *client_meta, ::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$setup_callback_blocking(::com::crypto::game_sdk::WalletconnectClient &self, ::com::crypto::game_sdk::WalletConnectCallback *usercallback) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$ensure_session_blocking(::com::crypto::game_sdk::WalletconnectClient &self, ::com::crypto::game_sdk::WalletConnectEnsureSessionResult *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ensure_session_blocking(::com::crypto::game_sdk::Walletconnect2Client &self, ::std::uint64_t waitmillis, ::com::crypto::game_sdk::WalletConnect2EnsureSessionResult *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$poll_events_blocking(::com::crypto::game_sdk::Walletconnect2Client &self, ::std::uint64_t waitmillis, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$get_connection_string(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$get_connection_string(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$save_client(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$save_client(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$print_uri(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$print_uri(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_personal_blocking(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *message, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_personal_blocking(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *message, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ping_blocking(::com::crypto::game_sdk::Walletconnect2Client &self, ::std::uint64_t waitmillis, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_eip155_transaction_blocking(::com::crypto::game_sdk::WalletconnectClient &self, ::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_eip155_transaction_blocking(::com::crypto::game_sdk::Walletconnect2Client &self, ::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_eip155_transaction_blocking(::com::crypto::game_sdk::WalletconnectClient &self, ::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_eip155_transaction_blocking(::com::crypto::game_sdk::Walletconnect2Client &self, ::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_transaction(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *eip1559_transaction_request, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_transaction(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *eip1559_transaction_request, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_transaction(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *eip1559_transaction_request, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_transaction(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *eip1559_transaction_request, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_contract_transaction(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_contract_transaction(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_contract_transaction(::com::crypto::game_sdk::WalletconnectClient &self, ::rust::String *contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_contract_transaction(::com::crypto::game_sdk::Walletconnect2Client &self, ::rust::String *contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> *address, ::rust::Vec<::std::uint8_t> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_transaction_history_blocking(::rust::String *address, ::rust::String *api_key, ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_erc20_transfer_history_blocking(::rust::String *address, ::rust::String *contract_address, ::com::crypto::game_sdk::QueryOption option, ::rust::String *api_key, ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_erc721_transfer_history_blocking(::rust::String *address, ::rust::String *contract_address, ::com::crypto::game_sdk::QueryOption option, ::rust::String *api_key, ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_tokens_blocking(::rust::String *blockscout_base_url, ::rust::String *account_address, ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_token_transfers_blocking(::rust::String *blockscout_base_url, ::rust::String *address, ::rust::String *contract_address, ::com::crypto::game_sdk::QueryOption option, ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_token_holders(::rust::String *blockscout_base_url, ::rust::String *contract_address, ::std::uint64_t page, ::std::uint64_t offset, ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$create_payment(::rust::String *secret_or_publishable_api_key, ::rust::String *base_unit_amount, ::rust::String *currency, ::com::crypto::game_sdk::OptionalArguments const &optional_args, ::com::crypto::game_sdk::CryptoComPaymentResponse *return$) noexcept;
+
+::rust::repr::PtrLen com$crypto$game_sdk$cxxbridge1$get_payment(::rust::String *secret_or_publishable_api_key, ::rust::String *payment_id, ::com::crypto::game_sdk::CryptoComPaymentResponse *return$) noexcept;
+
+::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_description(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_description$)() const = &::com::crypto::game_sdk::OptionalArguments::get_description;
+  return ::rust::impl<::rust::Str>::repr((self.*get_description$)());
+}
+
+::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_metadata(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_metadata$)() const = &::com::crypto::game_sdk::OptionalArguments::get_metadata;
+  return ::rust::impl<::rust::Str>::repr((self.*get_metadata$)());
+}
+
+::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_order_id(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_order_id$)() const = &::com::crypto::game_sdk::OptionalArguments::get_order_id;
+  return ::rust::impl<::rust::Str>::repr((self.*get_order_id$)());
+}
+
+::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_return_url(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_return_url$)() const = &::com::crypto::game_sdk::OptionalArguments::get_return_url;
+  return ::rust::impl<::rust::Str>::repr((self.*get_return_url$)());
+}
+
+::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_cancel_url(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_cancel_url$)() const = &::com::crypto::game_sdk::OptionalArguments::get_cancel_url;
+  return ::rust::impl<::rust::Str>::repr((self.*get_cancel_url$)());
+}
+
+::rust::repr::Fat com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_sub_merchant_id(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  ::rust::Str (::com::crypto::game_sdk::OptionalArguments::*get_sub_merchant_id$)() const = &::com::crypto::game_sdk::OptionalArguments::get_sub_merchant_id;
+  return ::rust::impl<::rust::Str>::repr((self.*get_sub_merchant_id$)());
+}
+
+bool com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_onchain_allowed(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  bool (::com::crypto::game_sdk::OptionalArguments::*get_onchain_allowed$)() const = &::com::crypto::game_sdk::OptionalArguments::get_onchain_allowed;
+  return (self.*get_onchain_allowed$)();
+}
+
+::std::uint64_t com$crypto$game_sdk$cxxbridge1$OptionalArguments$get_expired_at(::com::crypto::game_sdk::OptionalArguments const &self) noexcept {
+  ::std::uint64_t (::com::crypto::game_sdk::OptionalArguments::*get_expired_at$)() const = &::com::crypto::game_sdk::OptionalArguments::get_expired_at;
+  return (self.*get_expired_at$)();
 }
 } // extern "C"
 
 bool RawTxDetail::operator==(RawTxDetail const &rhs) const noexcept {
-    return com$crypto$game_sdk$cxxbridge1$RawTxDetail$operator$eq(*this, rhs);
+  return com$crypto$game_sdk$cxxbridge1$RawTxDetail$operator$eq(*this, rhs);
 }
 
 bool RawTxDetail::operator!=(RawTxDetail const &rhs) const noexcept {
-    return !(*this == rhs);
+  return !(*this == rhs);
 }
 
 bool RawTokenResult::operator==(RawTokenResult const &rhs) const noexcept {
-    return com$crypto$game_sdk$cxxbridge1$RawTokenResult$operator$eq(*this,
-                                                                     rhs);
+  return com$crypto$game_sdk$cxxbridge1$RawTokenResult$operator$eq(*this, rhs);
 }
 
 bool RawTokenResult::operator!=(RawTokenResult const &rhs) const noexcept {
-    return !(*this == rhs);
+  return !(*this == rhs);
 }
 
-bool TokenHolderDetail::operator==(
-    TokenHolderDetail const &rhs) const noexcept {
-    return com$crypto$game_sdk$cxxbridge1$TokenHolderDetail$operator$eq(*this,
-                                                                        rhs);
+bool TokenHolderDetail::operator==(TokenHolderDetail const &rhs) const noexcept {
+  return com$crypto$game_sdk$cxxbridge1$TokenHolderDetail$operator$eq(*this, rhs);
 }
 
-bool TokenHolderDetail::operator!=(
-    TokenHolderDetail const &rhs) const noexcept {
-    return !(*this == rhs);
+bool TokenHolderDetail::operator!=(TokenHolderDetail const &rhs) const noexcept {
+  return !(*this == rhs);
 }
 
 /// filter wallets by platform
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-::rust::Vec<::com::crypto::game_sdk::WalletEntry>
-filter_wallets(bool cached, ::rust::String registry_local_path,
-               ::com::crypto::game_sdk::Platform platform) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::WalletEntry>>
-        return$;
-    ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$filter_wallets(
-        cached, &registry_local_path, platform, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+::rust::Vec<::com::crypto::game_sdk::WalletEntry> filter_wallets(bool cached, ::rust::String registry_local_path, ::com::crypto::game_sdk::Platform platform) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::WalletEntry>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$filter_wallets(cached, &registry_local_path, platform, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// get all possible wallets
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-::rust::Vec<::com::crypto::game_sdk::WalletEntry>
-get_all_wallets(bool cached, ::rust::String registry_local_path) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::WalletEntry>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$get_all_wallets(
-            cached, &registry_local_path, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+::rust::Vec<::com::crypto::game_sdk::WalletEntry> get_all_wallets(bool cached, ::rust::String registry_local_path) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::WalletEntry>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_all_wallets(cached, &registry_local_path, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// check wallet by `id` for supported `platform` listing or not
 /// Check wallet id at https://explorer.walletconnect.com/
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-bool check_wallet(bool cached, ::rust::String registry_local_path,
-                  ::rust::String id,
-                  ::com::crypto::game_sdk::Platform platform) {
-    ::rust::MaybeUninit<bool> return$;
-    ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$check_wallet(
-        cached, &registry_local_path, &id, platform, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+bool check_wallet(bool cached, ::rust::String registry_local_path, ::rust::String id, ::com::crypto::game_sdk::Platform platform) {
+  ::rust::MaybeUninit<bool> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$check_wallet(cached, &registry_local_path, &id, platform, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// get a wallet by `id`
 /// Check wallet id at https://explorer.walletconnect.com/
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-::com::crypto::game_sdk::WalletEntry
-get_wallet(bool cached, ::rust::String registry_local_path, ::rust::String id) {
-    ::rust::MaybeUninit<::com::crypto::game_sdk::WalletEntry> return$;
-    ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_wallet(
-        cached, &registry_local_path, &id, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+::com::crypto::game_sdk::WalletEntry get_wallet(bool cached, ::rust::String registry_local_path, ::rust::String id) {
+  ::rust::MaybeUninit<::com::crypto::game_sdk::WalletEntry> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_wallet(cached, &registry_local_path, &id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::com::crypto::game_sdk::WalletQrcode
-generate_qrcode(::rust::String qrcodestring) {
-    ::rust::MaybeUninit<::com::crypto::game_sdk::WalletQrcode> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$generate_qrcode(&qrcodestring,
-                                                       &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::com::crypto::game_sdk::WalletQrcode generate_qrcode(::rust::String qrcodestring) {
+  ::rust::MaybeUninit<::com::crypto::game_sdk::WalletQrcode> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$generate_qrcode(&qrcodestring, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::std::size_t WalletconnectClient::layout::size() noexcept {
-    return com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$sizeof();
+  return com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$sizeof();
 }
 
 ::std::size_t WalletconnectClient::layout::align() noexcept {
-    return com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$alignof();
+  return com$crypto$game_sdk$cxxbridge1$WalletconnectClient$operator$alignof();
 }
 
 ::std::size_t Walletconnect2Client::layout::size() noexcept {
-    return com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$sizeof();
+  return com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$sizeof();
 }
 
 ::std::size_t Walletconnect2Client::layout::align() noexcept {
-    return com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$alignof();
+  return com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$operator$alignof();
 }
 
 /// restore walletconnect-session from string
 ///
-::rust::Box<::com::crypto::game_sdk::WalletconnectClient>
-walletconnect_restore_client(::rust::String session_info) {
-    ::rust::MaybeUninit<
-        ::rust::Box<::com::crypto::game_sdk::WalletconnectClient>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$walletconnect_restore_client(
-            &session_info, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>
-walletconnect2_restore_client(::rust::String session_info) {
-    ::rust::MaybeUninit<
-        ::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$walletconnect2_restore_client(
-            &session_info, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// create walletconnect-session
-/// the chain id (if 0, retrived and decided by wallet, if > 0, decided by the
-/// client)
-::rust::Box<::com::crypto::game_sdk::WalletconnectClient>
-walletconnect_new_client(::rust::String description, ::rust::String url,
-                         ::rust::Vec<::rust::String> icon_urls,
-                         ::rust::String name, ::std::uint64_t chain_id) {
-    ::rust::ManuallyDrop<::rust::Vec<::rust::String>> icon_urls$(
-        ::std::move(icon_urls));
-    ::rust::MaybeUninit<
-        ::rust::Box<::com::crypto::game_sdk::WalletconnectClient>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$walletconnect_new_client(
-            &description, &url, &icon_urls$.value, &name, chain_id,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>
-walletconnect2_client_new(::rust::String relayserver, ::rust::String project_id,
-                          ::rust::String required_namespaces,
-                          ::rust::String client_meta) {
-    ::rust::MaybeUninit<
-        ::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$walletconnect2_client_new(
-            &relayserver, &project_id, &required_namespaces, &client_meta,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-void WalletconnectClient::setup_callback_blocking(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>
-        usercallback) {
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$setup_callback_blocking(
-            *this, usercallback.release());
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
+::rust::Box<::com::crypto::game_sdk::WalletconnectClient> walletconnect_restore_client(::rust::String session_info) {
+  ::rust::MaybeUninit<::rust::Box<::com::crypto::game_sdk::WalletconnectClient>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$walletconnect_restore_client(&session_info, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::com::crypto::game_sdk::WalletConnectEnsureSessionResult
-WalletconnectClient::ensure_session_blocking() {
-    ::rust::MaybeUninit<
-        ::com::crypto::game_sdk::WalletConnectEnsureSessionResult>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$ensure_session_blocking(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::com::crypto::game_sdk::WalletConnect2EnsureSessionResult
-Walletconnect2Client::ensure_session_blocking(::std::uint64_t waitmillis) {
-    ::rust::MaybeUninit<
-        ::com::crypto::game_sdk::WalletConnect2EnsureSessionResult>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ensure_session_blocking(
-            *this, waitmillis, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> walletconnect2_restore_client(::rust::String session_info) {
+  ::rust::MaybeUninit<::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$walletconnect2_restore_client(&session_info, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
-::rust::String
-Walletconnect2Client::poll_events_blocking(::std::uint64_t waitmillis) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$poll_events_blocking(
-            *this, waitmillis, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+/// create walletconnect-session
+/// the chain id (if 0, retrived and decided by wallet, if > 0, decided by the client)
+::rust::Box<::com::crypto::game_sdk::WalletconnectClient> walletconnect_new_client(::rust::String description, ::rust::String url, ::rust::Vec<::rust::String> icon_urls, ::rust::String name, ::std::uint64_t chain_id) {
+  ::rust::ManuallyDrop<::rust::Vec<::rust::String>> icon_urls$(::std::move(icon_urls));
+  ::rust::MaybeUninit<::rust::Box<::com::crypto::game_sdk::WalletconnectClient>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$walletconnect_new_client(&description, &url, &icon_urls$.value, &name, chain_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> walletconnect2_client_new(::rust::String relayserver, ::rust::String project_id, ::rust::String required_namespaces, ::rust::String client_meta) {
+  ::rust::MaybeUninit<::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$walletconnect2_client_new(&relayserver, &project_id, &required_namespaces, &client_meta, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+void WalletconnectClient::setup_callback_blocking(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> usercallback) {
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$setup_callback_blocking(*this, usercallback.release());
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+}
+
+::com::crypto::game_sdk::WalletConnectEnsureSessionResult WalletconnectClient::ensure_session_blocking() {
+  ::rust::MaybeUninit<::com::crypto::game_sdk::WalletConnectEnsureSessionResult> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$ensure_session_blocking(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::com::crypto::game_sdk::WalletConnect2EnsureSessionResult Walletconnect2Client::ensure_session_blocking(::std::uint64_t waitmillis) {
+  ::rust::MaybeUninit<::com::crypto::game_sdk::WalletConnect2EnsureSessionResult> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ensure_session_blocking(*this, waitmillis, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::String Walletconnect2Client::poll_events_blocking(::std::uint64_t waitmillis) {
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$poll_events_blocking(*this, waitmillis, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String WalletconnectClient::get_connection_string() {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$get_connection_string(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$get_connection_string(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Walletconnect2Client::get_connection_string() {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$get_connection_string(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$get_connection_string(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String WalletconnectClient::save_client() {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$save_client(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$save_client(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Walletconnect2Client::save_client() {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$save_client(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$save_client(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String WalletconnectClient::print_uri() {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$print_uri(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$print_uri(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Walletconnect2Client::print_uri() {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$print_uri(
-            *this, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> WalletconnectClient::sign_personal_blocking(
-    ::rust::String message, ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_personal_blocking(
-            *this, &message, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> Walletconnect2Client::sign_personal_blocking(
-    ::rust::String message, ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_personal_blocking(
-            *this, &message, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$print_uri(*this, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> WalletconnectClient::sign_personal_blocking(::rust::String message, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_personal_blocking(*this, &message, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> Walletconnect2Client::sign_personal_blocking(::rust::String message, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_personal_blocking(*this, &message, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 ::rust::String Walletconnect2Client::ping_blocking(::std::uint64_t waitmillis) {
-    ::rust::MaybeUninit<::rust::String> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ping_blocking(
-            *this, waitmillis, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t>
-WalletconnectClient::sign_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_eip155_transaction_blocking(
-            *this, info, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t>
-Walletconnect2Client::sign_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_eip155_transaction_blocking(
-            *this, info, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t>
-WalletconnectClient::send_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_eip155_transaction_blocking(
-            *this, info, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t>
-Walletconnect2Client::send_eip155_transaction_blocking(
-    ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_eip155_transaction_blocking(
-            *this, info, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> WalletconnectClient::sign_transaction(
-    ::rust::String eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_transaction(
-            *this, &eip1559_transaction_request, &address$.value,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> Walletconnect2Client::sign_transaction(
-    ::rust::String eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_transaction(
-            *this, &eip1559_transaction_request, &address$.value,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> WalletconnectClient::send_transaction(
-    ::rust::String eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_transaction(
-            *this, &eip1559_transaction_request, &address$.value,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> Walletconnect2Client::send_transaction(
-    ::rust::String eip1559_transaction_request,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_transaction(
-            *this, &eip1559_transaction_request, &address$.value,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> WalletconnectClient::sign_contract_transaction(
-    ::rust::String contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_contract_transaction(
-            *this, &contract_action, common, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> Walletconnect2Client::sign_contract_transaction(
-    ::rust::String contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_contract_transaction(
-            *this, &contract_action, common, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> WalletconnectClient::send_contract_transaction(
-    ::rust::String contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_contract_transaction(
-            *this, &contract_action, common, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-::rust::Vec<::std::uint8_t> Walletconnect2Client::send_contract_transaction(
-    ::rust::String contract_action,
-    ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-    ::std::array<::std::uint8_t, 20> address) {
-    ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(
-        ::std::move(address));
-    ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_contract_transaction(
-            *this, &contract_action, common, &address$.value, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+  ::rust::MaybeUninit<::rust::String> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$ping_blocking(*this, waitmillis, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> WalletconnectClient::sign_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_eip155_transaction_blocking(*this, info, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> Walletconnect2Client::sign_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_eip155_transaction_blocking(*this, info, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> WalletconnectClient::send_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_eip155_transaction_blocking(*this, info, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> Walletconnect2Client::send_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_eip155_transaction_blocking(*this, info, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> WalletconnectClient::sign_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_transaction(*this, &eip1559_transaction_request, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> Walletconnect2Client::sign_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_transaction(*this, &eip1559_transaction_request, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> WalletconnectClient::send_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_transaction(*this, &eip1559_transaction_request, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> Walletconnect2Client::send_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_transaction(*this, &eip1559_transaction_request, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> WalletconnectClient::sign_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$sign_contract_transaction(*this, &contract_action, common, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> Walletconnect2Client::sign_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$sign_contract_transaction(*this, &contract_action, common, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> WalletconnectClient::send_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$WalletconnectClient$send_contract_transaction(*this, &contract_action, common, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+::rust::Vec<::std::uint8_t> Walletconnect2Client::send_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address) {
+  ::rust::ManuallyDrop<::std::array<::std::uint8_t, 20>> address$(::std::move(address));
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$Walletconnect2Client$send_contract_transaction(*this, &contract_action, common, &address$.value, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// returns the transactions of a given address.
 /// The API key can be obtained from https://cronoscan.com
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_transaction_history_blocking(::rust::String address,
-                                 ::rust::String api_key) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$get_transaction_history_blocking(
-            &address, &api_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_transaction_history_blocking(::rust::String address, ::rust::String api_key) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_transaction_history_blocking(&address, &api_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// returns the ERC20 transfers of a given address of a given contract.
 /// (address can be empty if option is ByContract)
 /// default option is by address
 /// The API key can be obtained from https://cronoscan.com
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_erc20_transfer_history_blocking(::rust::String address,
-                                    ::rust::String contract_address,
-                                    ::com::crypto::game_sdk::QueryOption option,
-                                    ::rust::String api_key) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$get_erc20_transfer_history_blocking(
-            &address, &contract_address, option, &api_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_erc20_transfer_history_blocking(::rust::String address, ::rust::String contract_address, ::com::crypto::game_sdk::QueryOption option, ::rust::String api_key) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_erc20_transfer_history_blocking(&address, &contract_address, option, &api_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// returns the ERC721 transfers of a given address of a given contract.
 /// (address can be empty if option is ByContract)
 /// default option is by address
 /// The API key can be obtained from https://cronoscan.com
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_erc721_transfer_history_blocking(
-    ::rust::String address, ::rust::String contract_address,
-    ::com::crypto::game_sdk::QueryOption option, ::rust::String api_key) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$get_erc721_transfer_history_blocking(
-            &address, &contract_address, option, &api_key, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// given the BlockScout REST API base url and the account address
-/// (hexadecimal), it will return the list of all owned tokens (ref:
-/// https://cronos.org/explorer/testnet3/api-docs)
-::rust::Vec<::com::crypto::game_sdk::RawTokenResult>
-get_tokens_blocking(::rust::String blockscout_base_url,
-                    ::rust::String account_address) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTokenResult>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$get_tokens_blocking(
-            &blockscout_base_url, &account_address, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// given the BlockScout REST API base url and the account address (hexadecimal;
-/// required) and optional contract address (hexadecimal; optional -- it can be
-/// empty if the option is ByAddress), it will return all the token transfers
-/// (ERC20, ERC721... in the newer BlockScout releases, also ERC1155) (ref:
-/// https://cronos.org/explorer/testnet3/api-docs) NOTE: QueryOption::ByContract
-/// is not supported by BlockScout
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_token_transfers_blocking(::rust::String blockscout_base_url,
-                             ::rust::String address,
-                             ::rust::String contract_address,
-                             ::com::crypto::game_sdk::QueryOption option) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$get_token_transfers_blocking(
-            &blockscout_base_url, &address, &contract_address, option,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
-}
-
-/// given the BlockScout REST API base url and the contract address
-/// (hexadecimal),
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_erc721_transfer_history_blocking(::rust::String address, ::rust::String contract_address, ::com::crypto::game_sdk::QueryOption option, ::rust::String api_key) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_erc721_transfer_history_blocking(&address, &contract_address, option, &api_key, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+/// given the BlockScout REST API base url and the account address (hexadecimal),
+/// it will return the list of all owned tokens
+/// (ref: https://cronos.org/explorer/testnet3/api-docs)
+::rust::Vec<::com::crypto::game_sdk::RawTokenResult> get_tokens_blocking(::rust::String blockscout_base_url, ::rust::String account_address) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTokenResult>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_tokens_blocking(&blockscout_base_url, &account_address, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+/// given the BlockScout REST API base url and the account address (hexadecimal; required)
+/// and optional contract address (hexadecimal; optional -- it can be empty if the option is ByAddress),
+/// it will return all the token transfers (ERC20, ERC721... in the newer BlockScout
+/// releases, also ERC1155)
+/// (ref: https://cronos.org/explorer/testnet3/api-docs)
+/// NOTE: QueryOption::ByContract is not supported by BlockScout
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_token_transfers_blocking(::rust::String blockscout_base_url, ::rust::String address, ::rust::String contract_address, ::com::crypto::game_sdk::QueryOption option) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::RawTxDetail>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_token_transfers_blocking(&blockscout_base_url, &address, &contract_address, option, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
+}
+
+/// given the BlockScout REST API base url and the contract address (hexadecimal),
 ///
 /// page: A nonnegative integer that represents the page number to be used for
 /// pagination. 'offset' must be provided in conjunction.
 ///
-/// offset: A nonnegative integer that represents the maximum number of records
-/// to return when paginating. 'page' must be provided in conjunction.
+/// offset: A nonnegative integer that represents the maximum number of records to
+/// return when paginating. 'page' must be provided in conjunction.
 ///
-/// it will return the list of owners and balances (sorting from largest to
-/// smallest), but no token ids.
+/// it will return the list of owners and balances (sorting from largest to smallest),
+/// but no token ids.
 ///
 /// (ref: https://cronos.org/explorer/api-docs#token)
 ///
 /// ::TIPS:: Use another functions to get more token/owner details, e.g.
 /// `get_tokens_blocking` to get owned tokens by account_address
-::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail>
-get_token_holders(::rust::String blockscout_base_url,
-                  ::rust::String contract_address, ::std::uint64_t page,
-                  ::std::uint64_t offset) {
-    ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail>>
-        return$;
-    ::rust::repr::PtrLen error$ =
-        com$crypto$game_sdk$cxxbridge1$get_token_holders(
-            &blockscout_base_url, &contract_address, page, offset,
-            &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> get_token_holders(::rust::String blockscout_base_url, ::rust::String contract_address, ::std::uint64_t page, ::std::uint64_t offset) {
+  ::rust::MaybeUninit<::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail>> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_token_holders(&blockscout_base_url, &contract_address, page, offset, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// it creates the payment object
 /// https://pay-docs.crypto.com/#api-reference-resources-payments-create-a-payment
 /// This API can be called using either your Secret Key or Publishable Key.
-/// The amount should be given in base units (e.g. for USD, the base unit is
-/// cents 1 USD == 100 cents).
-::com::crypto::game_sdk::CryptoComPaymentResponse create_payment(
-    ::rust::String secret_or_publishable_api_key,
-    ::rust::String base_unit_amount, ::rust::String currency,
-    ::com::crypto::game_sdk::OptionalArguments const &optional_args) {
-    ::rust::MaybeUninit<::com::crypto::game_sdk::CryptoComPaymentResponse>
-        return$;
-    ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$create_payment(
-        &secret_or_publishable_api_key, &base_unit_amount, &currency,
-        optional_args, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+/// The amount should be given in base units (e.g. for USD, the base unit is cents 1 USD == 100 cents).
+::com::crypto::game_sdk::CryptoComPaymentResponse create_payment(::rust::String secret_or_publishable_api_key, ::rust::String base_unit_amount, ::rust::String currency, ::com::crypto::game_sdk::OptionalArguments const &optional_args) {
+  ::rust::MaybeUninit<::com::crypto::game_sdk::CryptoComPaymentResponse> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$create_payment(&secret_or_publishable_api_key, &base_unit_amount, &currency, optional_args, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 
 /// it returns the payment object by id
 /// https://pay-docs.crypto.com/#api-reference-resources-payments-get-payment-by-id
 /// This API can be called using either your Secret Key or Publishable Key.
-::com::crypto::game_sdk::CryptoComPaymentResponse
-get_payment(::rust::String secret_or_publishable_api_key,
-            ::rust::String payment_id) {
-    ::rust::MaybeUninit<::com::crypto::game_sdk::CryptoComPaymentResponse>
-        return$;
-    ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_payment(
-        &secret_or_publishable_api_key, &payment_id, &return$.value);
-    if (error$.ptr) {
-        throw ::rust::impl<::rust::Error>::error(error$);
-    }
-    return ::std::move(return$.value);
+::com::crypto::game_sdk::CryptoComPaymentResponse get_payment(::rust::String secret_or_publishable_api_key, ::rust::String payment_id) {
+  ::rust::MaybeUninit<::com::crypto::game_sdk::CryptoComPaymentResponse> return$;
+  ::rust::repr::PtrLen error$ = com$crypto$game_sdk$cxxbridge1$get_payment(&secret_or_publishable_api_key, &payment_id, &return$.value);
+  if (error$.ptr) {
+    throw ::rust::impl<::rust::Error>::error(error$);
+  }
+  return ::std::move(return$.value);
 }
 } // namespace game_sdk
 } // namespace crypto
 } // namespace com
 
 extern "C" {
-static_assert(::rust::detail::is_complete<
-                  ::com::crypto::game_sdk::WalletConnectSessionInfo>::value,
-              "definition of WalletConnectSessionInfo is required");
-static_assert(
-    sizeof(
-        ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>) ==
-        sizeof(void *),
-    "");
-static_assert(
-    alignof(
-        ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>) ==
-        alignof(void *),
-    "");
-void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$null(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>
-        *ptr) noexcept {
-    ::new (ptr)::std::unique_ptr<
-        ::com::crypto::game_sdk::WalletConnectSessionInfo>();
-}
-void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$raw(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> *ptr,
-    ::com::crypto::game_sdk::WalletConnectSessionInfo *raw) noexcept {
-    ::new (ptr)::std::unique_ptr<
-        ::com::crypto::game_sdk::WalletConnectSessionInfo>(raw);
-}
-::com::crypto::game_sdk::WalletConnectSessionInfo const *
-cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$get(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> const
-        &ptr) noexcept {
-    return ptr.get();
-}
-::com::crypto::game_sdk::WalletConnectSessionInfo *
-cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$release(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>
-        &ptr) noexcept {
-    return ptr.release();
-}
-void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$drop(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>
-        *ptr) noexcept {
-    ::rust::deleter_if<::rust::detail::is_complete<
-        ::com::crypto::game_sdk::WalletConnectSessionInfo>::value>{}(ptr);
-}
-
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$new(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const
-        *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$drop(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$len(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const
-        *ptr) noexcept;
-::std::size_t
-cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$capacity(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const
-        *ptr) noexcept;
-::com::crypto::game_sdk::WalletConnectAddress const *
-cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$data(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const
-        *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$reserve_total(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$set_len(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$truncate(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr,
-    ::std::size_t len) noexcept;
-
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$new(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const
-        *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$drop(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>
-        *ptr) noexcept;
-::std::size_t
-cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$len(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const
-        *ptr) noexcept;
-::std::size_t
-cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$capacity(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const
-        *ptr) noexcept;
-::com::crypto::game_sdk::WalletConnect2Eip155Accounts const *
-cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$data(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const
-        *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$reserve_total(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$set_len(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$truncate(
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> *ptr,
-    ::std::size_t len) noexcept;
-
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$new(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$drop(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$len(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$capacity(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
-::com::crypto::game_sdk::WalletEntry const *
-cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$data(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$reserve_total(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$set_len(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$truncate(
-    ::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr,
-    ::std::size_t len) noexcept;
-
-::com::crypto::game_sdk::WalletconnectClient *
-cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$alloc() noexcept;
-void cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$dealloc(
-    ::com::crypto::game_sdk::WalletconnectClient *) noexcept;
-void cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$drop(
-    ::rust::Box<::com::crypto::game_sdk::WalletconnectClient> *ptr) noexcept;
-
-::com::crypto::game_sdk::Walletconnect2Client *
-cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$alloc() noexcept;
-void cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$dealloc(
-    ::com::crypto::game_sdk::Walletconnect2Client *) noexcept;
-void cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$drop(
-    ::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> *ptr) noexcept;
-
-static_assert(::rust::detail::is_complete<
-                  ::com::crypto::game_sdk::WalletConnectCallback>::value,
-              "definition of WalletConnectCallback is required");
-static_assert(
-    sizeof(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>) ==
-        sizeof(void *),
-    "");
-static_assert(
-    alignof(
-        ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>) ==
-        alignof(void *),
-    "");
-void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$null(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>
-        *ptr) noexcept {
-    ::new (
-        ptr)::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>();
-}
-void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$raw(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> *ptr,
-    ::com::crypto::game_sdk::WalletConnectCallback *raw) noexcept {
-    ::new (ptr)::std::unique_ptr<
-        ::com::crypto::game_sdk::WalletConnectCallback>(raw);
-}
-::com::crypto::game_sdk::WalletConnectCallback const *
-cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$get(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> const
-        &ptr) noexcept {
-    return ptr.get();
-}
-::com::crypto::game_sdk::WalletConnectCallback *
-cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$release(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>
-        &ptr) noexcept {
-    return ptr.release();
-}
-void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$drop(
-    ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>
-        *ptr) noexcept {
-    ::rust::deleter_if<::rust::detail::is_complete<
-        ::com::crypto::game_sdk::WalletConnectCallback>::value>{}(ptr);
-}
-
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$new(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$drop(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$len(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$capacity(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
-::com::crypto::game_sdk::RawTxDetail const *
-cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$data(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$reserve_total(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$set_len(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$truncate(
-    ::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr,
-    ::std::size_t len) noexcept;
-
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$new(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$drop(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$len(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$capacity(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
-::com::crypto::game_sdk::RawTokenResult const *
-cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$data(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$reserve_total(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$set_len(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$truncate(
-    ::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr,
-    ::std::size_t len) noexcept;
-
-void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$new(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const
-        *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$drop(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr) noexcept;
-::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$len(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const
-        *ptr) noexcept;
-::std::size_t
-cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$capacity(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const
-        *ptr) noexcept;
-::com::crypto::game_sdk::TokenHolderDetail const *
-cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$data(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const
-        *ptr) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$reserve_total(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr,
-    ::std::size_t new_cap) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$set_len(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr,
-    ::std::size_t len) noexcept;
-void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$truncate(
-    ::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr,
-    ::std::size_t len) noexcept;
+static_assert(::rust::detail::is_complete<::com::crypto::game_sdk::WalletConnectSessionInfo>::value, "definition of WalletConnectSessionInfo is required");
+static_assert(sizeof(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>) == sizeof(void *), "");
+static_assert(alignof(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>) == alignof(void *), "");
+void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$null(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> *ptr) noexcept {
+  ::new (ptr) ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>();
+}
+void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$raw(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> *ptr, ::com::crypto::game_sdk::WalletConnectSessionInfo *raw) noexcept {
+  ::new (ptr) ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo>(raw);
+}
+::com::crypto::game_sdk::WalletConnectSessionInfo const *cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$get(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> const &ptr) noexcept {
+  return ptr.get();
+}
+::com::crypto::game_sdk::WalletConnectSessionInfo *cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$release(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> &ptr) noexcept {
+  return ptr.release();
+}
+void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectSessionInfo$drop(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectSessionInfo> *ptr) noexcept {
+  ::rust::deleter_if<::rust::detail::is_complete<::com::crypto::game_sdk::WalletConnectSessionInfo>::value>{}(ptr);
+}
+
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$new(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$drop(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$len(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$capacity(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const *ptr) noexcept;
+::com::crypto::game_sdk::WalletConnectAddress const *cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$data(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$reserve_total(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$set_len(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$truncate(::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> *ptr, ::std::size_t len) noexcept;
+
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$new(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$drop(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$len(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$capacity(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const *ptr) noexcept;
+::com::crypto::game_sdk::WalletConnect2Eip155Accounts const *cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$data(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$reserve_total(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$set_len(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$truncate(::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> *ptr, ::std::size_t len) noexcept;
+
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$new(::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$drop(::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$len(::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$capacity(::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
+::com::crypto::game_sdk::WalletEntry const *cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$data(::rust::Vec<::com::crypto::game_sdk::WalletEntry> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$reserve_total(::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$set_len(::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$truncate(::rust::Vec<::com::crypto::game_sdk::WalletEntry> *ptr, ::std::size_t len) noexcept;
+
+::com::crypto::game_sdk::WalletconnectClient *cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$alloc() noexcept;
+void cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$dealloc(::com::crypto::game_sdk::WalletconnectClient *) noexcept;
+void cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$drop(::rust::Box<::com::crypto::game_sdk::WalletconnectClient> *ptr) noexcept;
+
+::com::crypto::game_sdk::Walletconnect2Client *cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$alloc() noexcept;
+void cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$dealloc(::com::crypto::game_sdk::Walletconnect2Client *) noexcept;
+void cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$drop(::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> *ptr) noexcept;
+
+static_assert(::rust::detail::is_complete<::com::crypto::game_sdk::WalletConnectCallback>::value, "definition of WalletConnectCallback is required");
+static_assert(sizeof(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>) == sizeof(void *), "");
+static_assert(alignof(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>) == alignof(void *), "");
+void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$null(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> *ptr) noexcept {
+  ::new (ptr) ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>();
+}
+void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$raw(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> *ptr, ::com::crypto::game_sdk::WalletConnectCallback *raw) noexcept {
+  ::new (ptr) ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>(raw);
+}
+::com::crypto::game_sdk::WalletConnectCallback const *cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$get(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> const &ptr) noexcept {
+  return ptr.get();
+}
+::com::crypto::game_sdk::WalletConnectCallback *cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$release(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> &ptr) noexcept {
+  return ptr.release();
+}
+void cxxbridge1$unique_ptr$com$crypto$game_sdk$WalletConnectCallback$drop(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> *ptr) noexcept {
+  ::rust::deleter_if<::rust::detail::is_complete<::com::crypto::game_sdk::WalletConnectCallback>::value>{}(ptr);
+}
+
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$new(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$drop(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$len(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$capacity(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
+::com::crypto::game_sdk::RawTxDetail const *cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$data(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$reserve_total(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$set_len(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$truncate(::rust::Vec<::com::crypto::game_sdk::RawTxDetail> *ptr, ::std::size_t len) noexcept;
+
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$new(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$drop(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$len(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$capacity(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
+::com::crypto::game_sdk::RawTokenResult const *cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$data(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$reserve_total(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$set_len(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$truncate(::rust::Vec<::com::crypto::game_sdk::RawTokenResult> *ptr, ::std::size_t len) noexcept;
+
+void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$new(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$drop(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$len(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const *ptr) noexcept;
+::std::size_t cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$capacity(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const *ptr) noexcept;
+::com::crypto::game_sdk::TokenHolderDetail const *cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$data(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> const *ptr) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$reserve_total(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr, ::std::size_t new_cap) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$set_len(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr, ::std::size_t len) noexcept;
+void cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$truncate(::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> *ptr, ::std::size_t len) noexcept;
 } // extern "C"
 
 namespace rust {
 inline namespace cxxbridge1 {
-template <> Vec<::com::crypto::game_sdk::WalletConnectAddress>::Vec() noexcept {
-    cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$new(this);
+template <>
+Vec<::com::crypto::game_sdk::WalletConnectAddress>::Vec() noexcept {
+  cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$new(this);
 }
 template <>
 void Vec<::com::crypto::game_sdk::WalletConnectAddress>::drop() noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$drop(
-        this);
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$drop(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::WalletConnectAddress>::size() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$len(
-        this);
+::std::size_t Vec<::com::crypto::game_sdk::WalletConnectAddress>::size() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$len(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::WalletConnectAddress>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$capacity(
-        this);
+::std::size_t Vec<::com::crypto::game_sdk::WalletConnectAddress>::capacity() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$capacity(this);
 }
 template <>
-::com::crypto::game_sdk::WalletConnectAddress const *
-Vec<::com::crypto::game_sdk::WalletConnectAddress>::data() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$data(
-        this);
+::com::crypto::game_sdk::WalletConnectAddress const *Vec<::com::crypto::game_sdk::WalletConnectAddress>::data() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$data(this);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletConnectAddress>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$reserve_total(
-        this, new_cap);
+void Vec<::com::crypto::game_sdk::WalletConnectAddress>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletConnectAddress>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$set_len(
-        this, len);
+void Vec<::com::crypto::game_sdk::WalletConnectAddress>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$set_len(this, len);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletConnectAddress>::truncate(
-    ::std::size_t len) {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$truncate(
-        this, len);
+void Vec<::com::crypto::game_sdk::WalletConnectAddress>::truncate(::std::size_t len) {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnectAddress$truncate(this, len);
 }
 template <>
 Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::Vec() noexcept {
-    cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$new(
-        this);
+  cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$new(this);
 }
 template <>
-void Vec<
-    ::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::drop() noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$drop(
-        this);
+void Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::drop() noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$drop(this);
 }
 template <>
-::std::size_t Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::size()
-    const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$len(
-        this);
+::std::size_t Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::size() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$len(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::capacity()
-    const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$capacity(
-        this);
+::std::size_t Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::capacity() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$capacity(this);
 }
 template <>
-::com::crypto::game_sdk::WalletConnect2Eip155Accounts const *
-Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::data()
-    const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$data(
-        this);
+::com::crypto::game_sdk::WalletConnect2Eip155Accounts const *Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::data() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$data(this);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$reserve_total(
-        this, new_cap);
+void Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$set_len(
-        this, len);
+void Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$set_len(this, len);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::truncate(
-    ::std::size_t len) {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$truncate(
-        this, len);
+void Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts>::truncate(::std::size_t len) {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletConnect2Eip155Accounts$truncate(this, len);
 }
-template <> Vec<::com::crypto::game_sdk::WalletEntry>::Vec() noexcept {
-    cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$new(this);
+template <>
+Vec<::com::crypto::game_sdk::WalletEntry>::Vec() noexcept {
+  cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$new(this);
 }
-template <> void Vec<::com::crypto::game_sdk::WalletEntry>::drop() noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$drop(this);
+template <>
+void Vec<::com::crypto::game_sdk::WalletEntry>::drop() noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$drop(this);
 }
 template <>
 ::std::size_t Vec<::com::crypto::game_sdk::WalletEntry>::size() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$len(this);
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$len(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::WalletEntry>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$capacity(this);
+::std::size_t Vec<::com::crypto::game_sdk::WalletEntry>::capacity() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$capacity(this);
 }
 template <>
-::com::crypto::game_sdk::WalletEntry const *
-Vec<::com::crypto::game_sdk::WalletEntry>::data() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$data(this);
+::com::crypto::game_sdk::WalletEntry const *Vec<::com::crypto::game_sdk::WalletEntry>::data() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$data(this);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletEntry>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$reserve_total(
-        this, new_cap);
+void Vec<::com::crypto::game_sdk::WalletEntry>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::com::crypto::game_sdk::WalletEntry>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$set_len(this,
-                                                                       len);
+void Vec<::com::crypto::game_sdk::WalletEntry>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$set_len(this, len);
 }
 template <>
 void Vec<::com::crypto::game_sdk::WalletEntry>::truncate(::std::size_t len) {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$truncate(this,
-                                                                        len);
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$WalletEntry$truncate(this, len);
 }
 template <>
-::com::crypto::game_sdk::WalletconnectClient *
-Box<::com::crypto::game_sdk::WalletconnectClient>::allocation::
-    alloc() noexcept {
-    return cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$alloc();
+::com::crypto::game_sdk::WalletconnectClient *Box<::com::crypto::game_sdk::WalletconnectClient>::allocation::alloc() noexcept {
+  return cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$alloc();
 }
 template <>
-void Box<::com::crypto::game_sdk::WalletconnectClient>::allocation::dealloc(
-    ::com::crypto::game_sdk::WalletconnectClient *ptr) noexcept {
-    cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$dealloc(ptr);
+void Box<::com::crypto::game_sdk::WalletconnectClient>::allocation::dealloc(::com::crypto::game_sdk::WalletconnectClient *ptr) noexcept {
+  cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$dealloc(ptr);
 }
 template <>
 void Box<::com::crypto::game_sdk::WalletconnectClient>::drop() noexcept {
-    cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$drop(this);
+  cxxbridge1$box$com$crypto$game_sdk$WalletconnectClient$drop(this);
 }
 template <>
-::com::crypto::game_sdk::Walletconnect2Client *
-Box<::com::crypto::game_sdk::Walletconnect2Client>::allocation::
-    alloc() noexcept {
-    return cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$alloc();
+::com::crypto::game_sdk::Walletconnect2Client *Box<::com::crypto::game_sdk::Walletconnect2Client>::allocation::alloc() noexcept {
+  return cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$alloc();
 }
 template <>
-void Box<::com::crypto::game_sdk::Walletconnect2Client>::allocation::dealloc(
-    ::com::crypto::game_sdk::Walletconnect2Client *ptr) noexcept {
-    cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$dealloc(ptr);
+void Box<::com::crypto::game_sdk::Walletconnect2Client>::allocation::dealloc(::com::crypto::game_sdk::Walletconnect2Client *ptr) noexcept {
+  cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$dealloc(ptr);
 }
 template <>
 void Box<::com::crypto::game_sdk::Walletconnect2Client>::drop() noexcept {
-    cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$drop(this);
+  cxxbridge1$box$com$crypto$game_sdk$Walletconnect2Client$drop(this);
 }
-template <> Vec<::com::crypto::game_sdk::RawTxDetail>::Vec() noexcept {
-    cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$new(this);
+template <>
+Vec<::com::crypto::game_sdk::RawTxDetail>::Vec() noexcept {
+  cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$new(this);
 }
-template <> void Vec<::com::crypto::game_sdk::RawTxDetail>::drop() noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$drop(this);
+template <>
+void Vec<::com::crypto::game_sdk::RawTxDetail>::drop() noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$drop(this);
 }
 template <>
 ::std::size_t Vec<::com::crypto::game_sdk::RawTxDetail>::size() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$len(this);
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$len(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::RawTxDetail>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$capacity(this);
+::std::size_t Vec<::com::crypto::game_sdk::RawTxDetail>::capacity() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$capacity(this);
 }
 template <>
-::com::crypto::game_sdk::RawTxDetail const *
-Vec<::com::crypto::game_sdk::RawTxDetail>::data() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$data(this);
+::com::crypto::game_sdk::RawTxDetail const *Vec<::com::crypto::game_sdk::RawTxDetail>::data() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$data(this);
 }
 template <>
-void Vec<::com::crypto::game_sdk::RawTxDetail>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$reserve_total(
-        this, new_cap);
+void Vec<::com::crypto::game_sdk::RawTxDetail>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::com::crypto::game_sdk::RawTxDetail>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$set_len(this,
-                                                                       len);
+void Vec<::com::crypto::game_sdk::RawTxDetail>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$set_len(this, len);
 }
 template <>
 void Vec<::com::crypto::game_sdk::RawTxDetail>::truncate(::std::size_t len) {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$truncate(this,
-                                                                        len);
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTxDetail$truncate(this, len);
 }
-template <> Vec<::com::crypto::game_sdk::RawTokenResult>::Vec() noexcept {
-    cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$new(this);
+template <>
+Vec<::com::crypto::game_sdk::RawTokenResult>::Vec() noexcept {
+  cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$new(this);
 }
-template <> void Vec<::com::crypto::game_sdk::RawTokenResult>::drop() noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$drop(this);
+template <>
+void Vec<::com::crypto::game_sdk::RawTokenResult>::drop() noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$drop(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::RawTokenResult>::size() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$len(this);
+::std::size_t Vec<::com::crypto::game_sdk::RawTokenResult>::size() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$len(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::RawTokenResult>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$capacity(
-        this);
+::std::size_t Vec<::com::crypto::game_sdk::RawTokenResult>::capacity() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$capacity(this);
 }
 template <>
-::com::crypto::game_sdk::RawTokenResult const *
-Vec<::com::crypto::game_sdk::RawTokenResult>::data() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$data(this);
+::com::crypto::game_sdk::RawTokenResult const *Vec<::com::crypto::game_sdk::RawTokenResult>::data() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$data(this);
 }
 template <>
-void Vec<::com::crypto::game_sdk::RawTokenResult>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$reserve_total(
-        this, new_cap);
+void Vec<::com::crypto::game_sdk::RawTokenResult>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::com::crypto::game_sdk::RawTokenResult>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$set_len(this,
-                                                                          len);
+void Vec<::com::crypto::game_sdk::RawTokenResult>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$set_len(this, len);
 }
 template <>
 void Vec<::com::crypto::game_sdk::RawTokenResult>::truncate(::std::size_t len) {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$truncate(this,
-                                                                           len);
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$RawTokenResult$truncate(this, len);
 }
-template <> Vec<::com::crypto::game_sdk::TokenHolderDetail>::Vec() noexcept {
-    cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$new(this);
+template <>
+Vec<::com::crypto::game_sdk::TokenHolderDetail>::Vec() noexcept {
+  cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$new(this);
 }
 template <>
 void Vec<::com::crypto::game_sdk::TokenHolderDetail>::drop() noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$drop(this);
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$drop(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::TokenHolderDetail>::size() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$len(this);
+::std::size_t Vec<::com::crypto::game_sdk::TokenHolderDetail>::size() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$len(this);
 }
 template <>
-::std::size_t
-Vec<::com::crypto::game_sdk::TokenHolderDetail>::capacity() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$capacity(
-        this);
+::std::size_t Vec<::com::crypto::game_sdk::TokenHolderDetail>::capacity() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$capacity(this);
 }
 template <>
-::com::crypto::game_sdk::TokenHolderDetail const *
-Vec<::com::crypto::game_sdk::TokenHolderDetail>::data() const noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$data(this);
+::com::crypto::game_sdk::TokenHolderDetail const *Vec<::com::crypto::game_sdk::TokenHolderDetail>::data() const noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$data(this);
 }
 template <>
-void Vec<::com::crypto::game_sdk::TokenHolderDetail>::reserve_total(
-    ::std::size_t new_cap) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$reserve_total(
-        this, new_cap);
+void Vec<::com::crypto::game_sdk::TokenHolderDetail>::reserve_total(::std::size_t new_cap) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$reserve_total(this, new_cap);
 }
 template <>
-void Vec<::com::crypto::game_sdk::TokenHolderDetail>::set_len(
-    ::std::size_t len) noexcept {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$set_len(
-        this, len);
+void Vec<::com::crypto::game_sdk::TokenHolderDetail>::set_len(::std::size_t len) noexcept {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$set_len(this, len);
 }
 template <>
-void Vec<::com::crypto::game_sdk::TokenHolderDetail>::truncate(
-    ::std::size_t len) {
-    return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$truncate(
-        this, len);
+void Vec<::com::crypto::game_sdk::TokenHolderDetail>::truncate(::std::size_t len) {
+  return cxxbridge1$rust_vec$com$crypto$game_sdk$TokenHolderDetail$truncate(this, len);
 }
 } // namespace cxxbridge1
 } // namespace rust
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.h
index 4e5ff0c7..440fdc6d 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/extra-cpp-bindings/src/lib.rs.h
@@ -22,755 +22,822 @@ inline namespace cxxbridge1 {
 
 #ifndef CXXBRIDGE1_PANIC
 #define CXXBRIDGE1_PANIC
-template <typename Exception> void panic [[noreturn]] (const char *msg);
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
 #endif // CXXBRIDGE1_PANIC
 
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+template <typename T>
+class impl;
 } // namespace
 
-template <typename T>::std::size_t size_of();
-template <typename T>::std::size_t align_of();
+template <typename T>
+::std::size_t size_of();
+template <typename T>
+::std::size_t align_of();
 
 #ifndef CXXBRIDGE1_RUST_STRING
 #define CXXBRIDGE1_RUST_STRING
 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);
-
-    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;
-
-    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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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);
+
+  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;
+
+  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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 #endif // CXXBRIDGE1_RUST_STRING
 
 #ifndef CXXBRIDGE1_RUST_STR
 #define CXXBRIDGE1_RUST_STR
 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;
-
-    const char *data() const noexcept;
-    std::size_t size() const noexcept;
-    std::size_t length() const noexcept;
-    bool empty() const noexcept;
-
-    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;
+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;
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  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
 #define 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;
+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
 
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  T &operator[](std::size_t n) const noexcept;
+  T &at(std::size_t n) const;
+  T &front() const noexcept;
+  T &back() const noexcept;
 
-    Slice(const Slice<T> &) noexcept = default;
-    ~Slice() noexcept = default;
+  Slice(const Slice<T> &) noexcept = default;
+  ~Slice() noexcept = default;
 
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
 };
 
-template <typename T> Slice<T>::Slice() noexcept {
-    sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
+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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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 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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  void swap(Box &) noexcept;
 
-    static Box from_raw(T *) noexcept;
+  static Box from_raw(T *) noexcept;
 
-    T *into_raw() noexcept;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  T *ptr;
 };
 
-template <typename T> class Box<T>::uninit {};
+template <typename T>
+class Box<T>::uninit {};
 
-template <typename T> class Box<T>::allocation {
-    static T *alloc() noexcept;
-    static void dealloc(T *) noexcept;
+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);
-        }
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
     }
-    T *ptr;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
 #endif // CXXBRIDGE1_RUST_BOX
 
 #ifndef CXXBRIDGE1_RUST_BITCOPY_T
 #define CXXBRIDGE1_RUST_BITCOPY_T
 struct unsafe_bitcopy_t final {
-    explicit unsafe_bitcopy_t() = default;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
 #ifndef CXXBRIDGE1_RUST_VEC
 #define CXXBRIDGE1_RUST_VEC
-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;
-
-    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); }
-
-    std::array<std::uintptr_t, 3> repr;
+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;
+
+  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); }
+
+  std::array<std::uintptr_t, 3> repr;
 };
 
-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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+template <typename T>
+void Vec<T>::swap(Vec &rhs) noexcept {
+  using std::swap;
+  swap(this->repr, rhs.repr);
 }
 
 template <typename T>
@@ -780,10 +847,10 @@ Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
 #ifndef CXXBRIDGE1_RUST_OPAQUE
 #define CXXBRIDGE1_RUST_OPAQUE
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
 };
 #endif // CXXBRIDGE1_RUST_OPAQUE
 
@@ -802,82 +869,89 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
 #endif // CXXBRIDGE1_LAYOUT
 } // namespace cxxbridge1
 } // namespace rust
 
 namespace com {
-namespace crypto {
-namespace game_sdk {
-struct WalletConnectTransactionReceiptRaw;
-using WalletConnectCallback = ::com::crypto::game_sdk::WalletConnectCallback;
-using WalletConnectSessionInfo =
-    ::com::crypto::game_sdk::WalletConnectSessionInfo;
-struct WalletEntry;
-enum class Platform : ::std::uint8_t;
-struct ImageUrl;
-struct WalletQrcode;
-struct WalletConnectTxCommon;
-struct WalletConnectTxEip155;
-struct WalletConnectAddress;
-struct WalletConnectEnsureSessionResult;
-struct WalletConnect2Eip155Accounts;
-struct WalletConnect2Eip155;
-struct WalletConnect2EnsureSessionResult;
-struct CryptoComPaymentResponse;
-struct RawTxDetail;
-struct RawTokenResult;
-struct TokenHolderDetail;
-enum class QueryOption : ::std::uint8_t;
-struct WalletconnectClient;
-struct Walletconnect2Client;
-using OptionalArguments = ::com::crypto::game_sdk::OptionalArguments;
-} // namespace game_sdk
-} // namespace crypto
-} // namespace com
+  namespace crypto {
+    namespace game_sdk {
+      struct WalletConnectTransactionReceiptRaw;
+      using WalletConnectCallback = ::com::crypto::game_sdk::WalletConnectCallback;
+      using WalletConnectSessionInfo = ::com::crypto::game_sdk::WalletConnectSessionInfo;
+      struct WalletEntry;
+      enum class Platform : ::std::uint8_t;
+      struct ImageUrl;
+      struct WalletQrcode;
+      struct WalletConnectTxCommon;
+      struct WalletConnectTxEip155;
+      struct WalletConnectAddress;
+      struct WalletConnectEnsureSessionResult;
+      struct WalletConnect2Eip155Accounts;
+      struct WalletConnect2Eip155;
+      struct WalletConnect2EnsureSessionResult;
+      struct CryptoComPaymentResponse;
+      struct RawTxDetail;
+      struct RawTokenResult;
+      struct TokenHolderDetail;
+      enum class QueryOption : ::std::uint8_t;
+      struct WalletconnectClient;
+      struct Walletconnect2Client;
+      using OptionalArguments = ::com::crypto::game_sdk::OptionalArguments;
+    }
+  }
+}
 
 namespace com {
 namespace crypto {
@@ -885,23 +959,23 @@ namespace game_sdk {
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTransactionReceiptRaw
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTransactionReceiptRaw
 struct WalletConnectTransactionReceiptRaw final {
-    ::rust::Vec<::std::uint8_t> transaction_hash;
-    ::rust::String transaction_index;
-    ::rust::Vec<::std::uint8_t> block_hash;
-    ::rust::String block_number;
-    ::rust::String cumulative_gas_used;
-    ::rust::String gas_used;
-    ::rust::String contract_address;
-    ::rust::Vec<::rust::String> logs;
-    /// Status: either 1 (success) or 0 (failure)
-    ///
-    ::rust::String status;
-    ::rust::Vec<::std::uint8_t> root;
-    ::rust::Vec<::std::uint8_t> logs_bloom;
-    ::rust::String transaction_type;
-    ::rust::String effective_gas_price;
-
-    using IsRelocatable = ::std::true_type;
+  ::rust::Vec<::std::uint8_t> transaction_hash;
+  ::rust::String transaction_index;
+  ::rust::Vec<::std::uint8_t> block_hash;
+  ::rust::String block_number;
+  ::rust::String cumulative_gas_used;
+  ::rust::String gas_used;
+  ::rust::String contract_address;
+  ::rust::Vec<::rust::String> logs;
+  /// Status: either 1 (success) or 0 (failure)
+  ///
+  ::rust::String status;
+  ::rust::Vec<::std::uint8_t> root;
+  ::rust::Vec<::std::uint8_t> logs_bloom;
+  ::rust::String transaction_type;
+  ::rust::String effective_gas_price;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTransactionReceiptRaw
 
@@ -910,17 +984,17 @@ struct WalletConnectTransactionReceiptRaw final {
 /// The icon URLs
 ///
 struct ImageUrl final {
-    /// small
-    ///
-    ::rust::String sm;
-    /// medium
-    ///
-    ::rust::String md;
-    /// large
-    ///
-    ::rust::String lg;
-
-    using IsRelocatable = ::std::true_type;
+  /// small
+  ///
+  ::rust::String sm;
+  /// medium
+  ///
+  ::rust::String md;
+  /// large
+  ///
+  ::rust::String lg;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$ImageUrl
 
@@ -929,29 +1003,29 @@ struct ImageUrl final {
 /// The wallet registry entry
 ///
 struct WalletEntry final {
-    /// wallet id
-    ///
-    ::rust::String id;
-    /// its name
-    ///
-    ::rust::String name;
-    /// icon URLs
-    ///
-    ::com::crypto::game_sdk::ImageUrl image_url;
-    /// mobile native link, empty if none
-    ///
-    ::rust::String mobile_native_link;
-    /// mobile universal link, empty if none
-    ///
-    ::rust::String mobile_universal_link;
-    /// desktop native link, empty if none
-    ///
-    ::rust::String desktop_native_link;
-    /// desktop universal link, empty if none
-    ///
-    ::rust::String desktop_universal_link;
-
-    using IsRelocatable = ::std::true_type;
+  /// wallet id
+  ///
+  ::rust::String id;
+  /// its name
+  ///
+  ::rust::String name;
+  /// icon URLs
+  ///
+  ::com::crypto::game_sdk::ImageUrl image_url;
+  /// mobile native link, empty if none
+  ///
+  ::rust::String mobile_native_link;
+  /// mobile universal link, empty if none
+  ///
+  ::rust::String mobile_universal_link;
+  /// desktop native link, empty if none
+  ///
+  ::rust::String desktop_native_link;
+  /// desktop universal link, empty if none
+  ///
+  ::rust::String desktop_universal_link;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletEntry
 
@@ -960,32 +1034,32 @@ struct WalletEntry final {
 /// The target platform
 ///
 enum class Platform : ::std::uint8_t {
-    Mobile = 0,
-    Desktop = 1,
+  Mobile = 0,
+  Desktop = 1,
 };
 #endif // CXXBRIDGE1_ENUM_com$crypto$game_sdk$Platform
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletQrcode
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletQrcode
 struct WalletQrcode final {
-    ::rust::String qrcode;
-    ::rust::Vec<::std::uint8_t> image;
-    ::std::uint32_t size;
+  ::rust::String qrcode;
+  ::rust::Vec<::std::uint8_t> image;
+  ::std::uint32_t size;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletQrcode
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxCommon
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxCommon
 struct WalletConnectTxCommon final {
-    ::rust::String gas_limit;
-    ::rust::String gas_price;
-    ::rust::String nonce;
-    ::std::uint64_t chainid;
-    ::rust::String web3api_url;
+  ::rust::String gas_limit;
+  ::rust::String gas_price;
+  ::rust::String nonce;
+  ::std::uint64_t chainid;
+  ::rust::String web3api_url;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxCommon
 
@@ -994,12 +1068,13 @@ struct WalletConnectTxCommon final {
 /// wallet connect cronos(eth) eip155-tx signing info
 ///
 struct WalletConnectTxEip155 final {
-    ::rust::String to;
-    ::rust::String value;
-    ::rust::Vec<::std::uint8_t> data;
-    ::com::crypto::game_sdk::WalletConnectTxCommon common;
+  ::rust::String from;
+  ::rust::String to;
+  ::rust::String value;
+  ::rust::Vec<::std::uint8_t> data;
+  ::com::crypto::game_sdk::WalletConnectTxCommon common;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectTxEip155
 
@@ -1008,9 +1083,9 @@ struct WalletConnectTxEip155 final {
 /// cronos address info
 ///
 struct WalletConnectAddress final {
-    ::std::array<::std::uint8_t, 20> address;
+  ::std::array<::std::uint8_t, 20> address;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectAddress
 
@@ -1019,40 +1094,40 @@ struct WalletConnectAddress final {
 /// walletconnect ensure-session result
 ///
 struct WalletConnectEnsureSessionResult final {
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> addresses;
-    ::std::uint64_t chain_id;
+  ::rust::Vec<::com::crypto::game_sdk::WalletConnectAddress> addresses;
+  ::std::uint64_t chain_id;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnectEnsureSessionResult
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155Accounts
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155Accounts
 struct WalletConnect2Eip155Accounts final {
-    ::com::crypto::game_sdk::WalletConnectAddress address;
-    ::std::uint64_t chain_id;
+  ::com::crypto::game_sdk::WalletConnectAddress address;
+  ::std::uint64_t chain_id;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155Accounts
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155
 struct WalletConnect2Eip155 final {
-    ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> accounts;
-    ::rust::Vec<::rust::String> methods;
-    ::rust::Vec<::rust::String> events;
+  ::rust::Vec<::com::crypto::game_sdk::WalletConnect2Eip155Accounts> accounts;
+  ::rust::Vec<::rust::String> methods;
+  ::rust::Vec<::rust::String> events;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2Eip155
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2EnsureSessionResult
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2EnsureSessionResult
 struct WalletConnect2EnsureSessionResult final {
-    ::com::crypto::game_sdk::WalletConnect2Eip155 eip155;
+  ::com::crypto::game_sdk::WalletConnect2Eip155 eip155;
 
-    using IsRelocatable = ::std::true_type;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletConnect2EnsureSessionResult
 
@@ -1061,64 +1136,63 @@ struct WalletConnect2EnsureSessionResult final {
 /// the subset of payment object from https://pay-docs.crypto.com
 ///
 struct CryptoComPaymentResponse final {
-    /// uuid of the payment object
-    ///
-    ::rust::String id;
-    /// the base64 payload to be displayed as QR code that
-    /// can be scanned by the main app
-    ::rust::String main_app_qr_code;
-    /// if the on-chain payment is desired, this will
-    /// have the cryptocurrency address that can be displayed
-    /// as a QR code or put in a tx to be signed via WalletConnect
-    ::rust::String onchain_deposit_address;
-    /// the amount in base denomination
-    /// e.g. for USD, it's cents (1 USD == 100 cents)
-    ::rust::String base_amount;
-    /// the 3-letter currency code
-    ///
-    ::rust::String currency;
-    /// expiration time in unix timestamp (10 minutes)
-    ///
-    ::std::uint64_t expiration;
-    /// the status of the payment
-    ///
-    ::rust::String status;
-
-    using IsRelocatable = ::std::true_type;
+  /// uuid of the payment object
+  ///
+  ::rust::String id;
+  /// the base64 payload to be displayed as QR code that
+  /// can be scanned by the main app
+  ::rust::String main_app_qr_code;
+  /// if the on-chain payment is desired, this will
+  /// have the cryptocurrency address that can be displayed
+  /// as a QR code or put in a tx to be signed via WalletConnect
+  ::rust::String onchain_deposit_address;
+  /// the amount in base denomination
+  /// e.g. for USD, it's cents (1 USD == 100 cents)
+  ::rust::String base_amount;
+  /// the 3-letter currency code
+  ///
+  ::rust::String currency;
+  /// expiration time in unix timestamp (10 minutes)
+  ///
+  ::std::uint64_t expiration;
+  /// the status of the payment
+  ///
+  ::rust::String status;
+
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$CryptoComPaymentResponse
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTxDetail
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTxDetail
-/// Raw transaction details (extracted from Cronoscan/Etherscan or BlockScout
-/// API)
+/// Raw transaction details (extracted from Cronoscan/Etherscan or BlockScout API)
 ///
 struct RawTxDetail final {
-    /// Transaction hash
-    ///
-    ::rust::String hash;
-    /// the hexadecimal address of the receiver
-    ///
-    ::rust::String to_address;
-    /// the hexadecimal address of the sender
-    ///
-    ::rust::String from_address;
-    /// the value sent in decimal (in base tokens)
-    ///
-    ::rust::String value;
-    /// block number when it happened
-    ///
-    ::std::uint64_t block_no;
-    /// the time it happened
-    ///
-    ::rust::String timestamp;
-    /// the address of the contract (if no contract, it's an empty string)
-    ///
-    ::rust::String contract_address;
-
-    bool operator==(RawTxDetail const &) const noexcept;
-    bool operator!=(RawTxDetail const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  /// Transaction hash
+  ///
+  ::rust::String hash;
+  /// the hexadecimal address of the receiver
+  ///
+  ::rust::String to_address;
+  /// the hexadecimal address of the sender
+  ///
+  ::rust::String from_address;
+  /// the value sent in decimal (in base tokens)
+  ///
+  ::rust::String value;
+  /// block number when it happened
+  ///
+  ::std::uint64_t block_no;
+  /// the time it happened
+  ///
+  ::rust::String timestamp;
+  /// the address of the contract (if no contract, it's an empty string)
+  ///
+  ::rust::String contract_address;
+
+  bool operator==(RawTxDetail const &) const noexcept;
+  bool operator!=(RawTxDetail const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTxDetail
 
@@ -1127,31 +1201,31 @@ struct RawTxDetail final {
 /// Token ownership result detail from BlockScout API
 ///
 struct RawTokenResult final {
-    /// how many tokens are owned by the address
-    ///
-    ::rust::String balance;
-    /// the deployed contract address
-    ///
-    ::rust::String contract_address;
-    /// the number of decimal places
-    ///
-    ::rust::String decimals;
-    /// the token id
-    ///
-    ::rust::String id;
-    /// the human-readable name of the token
-    ///
-    ::rust::String name;
-    /// the ticker for the token
-    ///
-    ::rust::String symbol;
-    /// the token type (ERC-20, ERC-721, ERC-1155)
-    ///
-    ::rust::String token_type;
-
-    bool operator==(RawTokenResult const &) const noexcept;
-    bool operator!=(RawTokenResult const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  /// how many tokens are owned by the address
+  ///
+  ::rust::String balance;
+  /// the deployed contract address
+  ///
+  ::rust::String contract_address;
+  /// the number of decimal places
+  ///
+  ::rust::String decimals;
+  /// the token id
+  ///
+  ::rust::String id;
+  /// the human-readable name of the token
+  ///
+  ::rust::String name;
+  /// the ticker for the token
+  ///
+  ::rust::String symbol;
+  /// the token type (ERC-20, ERC-721, ERC-1155)
+  ///
+  ::rust::String token_type;
+
+  bool operator==(RawTokenResult const &) const noexcept;
+  bool operator!=(RawTokenResult const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$RawTokenResult
 
@@ -1161,25 +1235,25 @@ struct RawTokenResult final {
 ///
 /// tokenid is not supported yet.
 struct TokenHolderDetail final {
-    /// the holder address
-    ///
-    ::rust::String address;
-    /// balance of the target token
-    ///
-    ::rust::String value;
-
-    bool operator==(TokenHolderDetail const &) const noexcept;
-    bool operator!=(TokenHolderDetail const &) const noexcept;
-    using IsRelocatable = ::std::true_type;
+  /// the holder address
+  ///
+  ::rust::String address;
+  /// balance of the target token
+  ///
+  ::rust::String value;
+
+  bool operator==(TokenHolderDetail const &) const noexcept;
+  bool operator!=(TokenHolderDetail const &) const noexcept;
+  using IsRelocatable = ::std::true_type;
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$TokenHolderDetail
 
 #ifndef CXXBRIDGE1_ENUM_com$crypto$game_sdk$QueryOption
 #define CXXBRIDGE1_ENUM_com$crypto$game_sdk$QueryOption
 enum class QueryOption : ::std::uint8_t {
-    ByContract = 0,
-    ByAddressAndContract = 1,
-    ByAddress = 2,
+  ByContract = 0,
+  ByAddressAndContract = 1,
+  ByAddress = 2,
 };
 #endif // CXXBRIDGE1_ENUM_com$crypto$game_sdk$QueryOption
 
@@ -1188,282 +1262,200 @@ enum class QueryOption : ::std::uint8_t {
 /// WallnetConnect API
 ///
 struct WalletconnectClient final : public ::rust::Opaque {
-    /// setup callback
-    ///
-    void setup_callback_blocking(
-        ::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback>
-            usercallback);
-
-    /// create or restore a session
-    /// once session is created, it will be reused
-    ::com::crypto::game_sdk::WalletConnectEnsureSessionResult
-    ensure_session_blocking();
-
-    /// get connection string for qrcode
-    ///
-    ::rust::String get_connection_string();
-
-    /// write session-info to string, which can be written to file
-    ///
-    ::rust::String save_client();
-
-    /// print qrcode in termal, for debugging
-    ///
-    ::rust::String print_uri();
-
-    /// sign message
-    ///
-    ::rust::Vec<::std::uint8_t>
-    sign_personal_blocking(::rust::String message,
-                           ::std::array<::std::uint8_t, 20> address);
-
-    /// build cronos(eth) eip155 transaction
-    /// Supported Wallets: Trust Wallet, Crypto.com Desktop Defi Wallet
-    ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-
-    /// send cronos(eth) eip155 transaction
-    /// Supported Wallets: Trust Wallet, MetaMask and Crypto.com Mobile Defi
-    /// Wallet
-    ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-
-    /// eip1559_transaction_request: json string of Eip1559TransactionRequest
-    /// return signed transaction bytes
-    ::rust::Vec<::std::uint8_t>
-    sign_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-
-    /// eip1559_transaction_request: json string of Eip1559TransactionRequest
-    /// return transaction hash bytes
-    ::rust::Vec<::std::uint8_t>
-    send_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-
-    /// sign a contract transaction
-    /// contract_action is a json string of `ContractAction` type, for example:
-    /// for example, transfer Erc20 token
-    /// {
-    ///     "ContractTransfer": {
-    ///         "Erc20Transfer": {
-    ///             "contract_address": "0xxxxx",
-    ///             "to_address": "0xxxxx",
-    ///             "amount": "1000000000000000000"
-    ///         }
-    ///     }
-    /// }
-    /// return signed transaction bytes
-    ::rust::Vec<::std::uint8_t> sign_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-
-    /// contract_action is a json string of `ContractAction` type
-    /// for example, transfer Erc20 token
-    /// {
-    ///     "ContractTransfer": {
-    ///         "Erc20Transfer": {
-    ///             "contract_address": "0xxxxx",
-    ///             "to_address": "0xxxxx",
-    ///             "amount": "1000000000000000000"
-    ///         }
-    ///     }
-    /// }
-    ::rust::Vec<::std::uint8_t> send_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-
-    ~WalletconnectClient() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  /// setup callback
+  ///
+  void setup_callback_blocking(::std::unique_ptr<::com::crypto::game_sdk::WalletConnectCallback> usercallback);
+
+  /// create or restore a session
+  /// once session is created, it will be reused
+  ::com::crypto::game_sdk::WalletConnectEnsureSessionResult ensure_session_blocking();
+
+  /// get connection string for qrcode
+  ///
+  ::rust::String get_connection_string();
+
+  /// write session-info to string, which can be written to file
+  ///
+  ::rust::String save_client();
+
+  /// print qrcode in termal, for debugging
+  ///
+  ::rust::String print_uri();
+
+  /// sign message
+  ///
+  ::rust::Vec<::std::uint8_t> sign_personal_blocking(::rust::String message, ::std::array<::std::uint8_t, 20> address);
+
+  /// build cronos(eth) eip155 transaction
+  /// Supported Wallets: Trust Wallet, Crypto.com Desktop Defi Wallet
+  ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+
+  /// send cronos(eth) eip155 transaction
+  /// Supported Wallets: Trust Wallet, MetaMask and Crypto.com Mobile Defi Wallet
+  ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+
+  /// eip1559_transaction_request: json string of Eip1559TransactionRequest
+  /// return signed transaction bytes
+  ::rust::Vec<::std::uint8_t> sign_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+
+  /// eip1559_transaction_request: json string of Eip1559TransactionRequest
+  /// return transaction hash bytes
+  ::rust::Vec<::std::uint8_t> send_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+
+  /// sign a contract transaction
+  /// contract_action is a json string of `ContractAction` type, for example:
+  /// for example, transfer Erc20 token
+  /// {
+  ///     "ContractTransfer": {
+  ///         "Erc20Transfer": {
+  ///             "contract_address": "0xxxxx",
+  ///             "to_address": "0xxxxx",
+  ///             "amount": "1000000000000000000"
+  ///         }
+  ///     }
+  /// }
+  /// return signed transaction bytes
+  ::rust::Vec<::std::uint8_t> sign_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+
+  /// contract_action is a json string of `ContractAction` type
+  /// for example, transfer Erc20 token
+  /// {
+  ///     "ContractTransfer": {
+  ///         "Erc20Transfer": {
+  ///             "contract_address": "0xxxxx",
+  ///             "to_address": "0xxxxx",
+  ///             "amount": "1000000000000000000"
+  ///         }
+  ///     }
+  /// }
+  ::rust::Vec<::std::uint8_t> send_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+
+  ~WalletconnectClient() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$WalletconnectClient
 
 #ifndef CXXBRIDGE1_STRUCT_com$crypto$game_sdk$Walletconnect2Client
 #define CXXBRIDGE1_STRUCT_com$crypto$game_sdk$Walletconnect2Client
 struct Walletconnect2Client final : public ::rust::Opaque {
-    ::com::crypto::game_sdk::WalletConnect2EnsureSessionResult
-    ensure_session_blocking(::std::uint64_t waitmillis);
-    ::rust::String poll_events_blocking(::std::uint64_t waitmillis);
-    ::rust::String get_connection_string();
-    ::rust::String save_client();
-    ::rust::String print_uri();
-    ::rust::Vec<::std::uint8_t>
-    sign_personal_blocking(::rust::String message,
-                           ::std::array<::std::uint8_t, 20> address);
-    ::rust::String ping_blocking(::std::uint64_t waitmillis);
-    ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(
-        ::com::crypto::game_sdk::WalletConnectTxEip155 const &info,
-        ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t>
-    sign_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t>
-    send_transaction(::rust::String eip1559_transaction_request,
-                     ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t> sign_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-    ::rust::Vec<::std::uint8_t> send_contract_transaction(
-        ::rust::String contract_action,
-        ::com::crypto::game_sdk::WalletConnectTxCommon const &common,
-        ::std::array<::std::uint8_t, 20> address);
-    ~Walletconnect2Client() = delete;
-
-  private:
-    friend ::rust::layout;
-    struct layout {
-        static ::std::size_t size() noexcept;
-        static ::std::size_t align() noexcept;
-    };
+  ::com::crypto::game_sdk::WalletConnect2EnsureSessionResult ensure_session_blocking(::std::uint64_t waitmillis);
+  ::rust::String poll_events_blocking(::std::uint64_t waitmillis);
+  ::rust::String get_connection_string();
+  ::rust::String save_client();
+  ::rust::String print_uri();
+  ::rust::Vec<::std::uint8_t> sign_personal_blocking(::rust::String message, ::std::array<::std::uint8_t, 20> address);
+  ::rust::String ping_blocking(::std::uint64_t waitmillis);
+  ::rust::Vec<::std::uint8_t> sign_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> send_eip155_transaction_blocking(::com::crypto::game_sdk::WalletConnectTxEip155 const &info, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> sign_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> send_transaction(::rust::String eip1559_transaction_request, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> sign_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+  ::rust::Vec<::std::uint8_t> send_contract_transaction(::rust::String contract_action, ::com::crypto::game_sdk::WalletConnectTxCommon const &common, ::std::array<::std::uint8_t, 20> address);
+  ~Walletconnect2Client() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
 };
 #endif // CXXBRIDGE1_STRUCT_com$crypto$game_sdk$Walletconnect2Client
 
 /// filter wallets by platform
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-::rust::Vec<::com::crypto::game_sdk::WalletEntry>
-filter_wallets(bool cached, ::rust::String registry_local_path,
-               ::com::crypto::game_sdk::Platform platform);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+::rust::Vec<::com::crypto::game_sdk::WalletEntry> filter_wallets(bool cached, ::rust::String registry_local_path, ::com::crypto::game_sdk::Platform platform);
 
 /// get all possible wallets
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-::rust::Vec<::com::crypto::game_sdk::WalletEntry>
-get_all_wallets(bool cached, ::rust::String registry_local_path);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+::rust::Vec<::com::crypto::game_sdk::WalletEntry> get_all_wallets(bool cached, ::rust::String registry_local_path);
 
 /// check wallet by `id` for supported `platform` listing or not
 /// Check wallet id at https://explorer.walletconnect.com/
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-bool check_wallet(bool cached, ::rust::String registry_local_path,
-                  ::rust::String id,
-                  ::com::crypto::game_sdk::Platform platform);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+bool check_wallet(bool cached, ::rust::String registry_local_path, ::rust::String id, ::com::crypto::game_sdk::Platform platform);
 
 /// get a wallet by `id`
 /// Check wallet id at https://explorer.walletconnect.com/
-/// (`registry_local_path` can be empty string if it is not needed to store the
-/// `cached` registry result)
-::com::crypto::game_sdk::WalletEntry
-get_wallet(bool cached, ::rust::String registry_local_path, ::rust::String id);
+/// (`registry_local_path` can be empty string if it is not needed to store the `cached` registry result)
+::com::crypto::game_sdk::WalletEntry get_wallet(bool cached, ::rust::String registry_local_path, ::rust::String id);
 
-::com::crypto::game_sdk::WalletQrcode
-generate_qrcode(::rust::String qrcodestring);
+::com::crypto::game_sdk::WalletQrcode generate_qrcode(::rust::String qrcodestring);
 
 /// restore walletconnect-session from string
 ///
-::rust::Box<::com::crypto::game_sdk::WalletconnectClient>
-walletconnect_restore_client(::rust::String session_info);
+::rust::Box<::com::crypto::game_sdk::WalletconnectClient> walletconnect_restore_client(::rust::String session_info);
 
-::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>
-walletconnect2_restore_client(::rust::String session_info);
+::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> walletconnect2_restore_client(::rust::String session_info);
 
 /// create walletconnect-session
-/// the chain id (if 0, retrived and decided by wallet, if > 0, decided by the
-/// client)
-::rust::Box<::com::crypto::game_sdk::WalletconnectClient>
-walletconnect_new_client(::rust::String description, ::rust::String url,
-                         ::rust::Vec<::rust::String> icon_urls,
-                         ::rust::String name, ::std::uint64_t chain_id);
-
-::rust::Box<::com::crypto::game_sdk::Walletconnect2Client>
-walletconnect2_client_new(::rust::String relayserver, ::rust::String project_id,
-                          ::rust::String required_namespaces,
-                          ::rust::String client_meta);
+/// the chain id (if 0, retrived and decided by wallet, if > 0, decided by the client)
+::rust::Box<::com::crypto::game_sdk::WalletconnectClient> walletconnect_new_client(::rust::String description, ::rust::String url, ::rust::Vec<::rust::String> icon_urls, ::rust::String name, ::std::uint64_t chain_id);
+
+::rust::Box<::com::crypto::game_sdk::Walletconnect2Client> walletconnect2_client_new(::rust::String relayserver, ::rust::String project_id, ::rust::String required_namespaces, ::rust::String client_meta);
 
 /// returns the transactions of a given address.
 /// The API key can be obtained from https://cronoscan.com
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_transaction_history_blocking(::rust::String address,
-                                 ::rust::String api_key);
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_transaction_history_blocking(::rust::String address, ::rust::String api_key);
 
 /// returns the ERC20 transfers of a given address of a given contract.
 /// (address can be empty if option is ByContract)
 /// default option is by address
 /// The API key can be obtained from https://cronoscan.com
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_erc20_transfer_history_blocking(::rust::String address,
-                                    ::rust::String contract_address,
-                                    ::com::crypto::game_sdk::QueryOption option,
-                                    ::rust::String api_key);
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_erc20_transfer_history_blocking(::rust::String address, ::rust::String contract_address, ::com::crypto::game_sdk::QueryOption option, ::rust::String api_key);
 
 /// returns the ERC721 transfers of a given address of a given contract.
 /// (address can be empty if option is ByContract)
 /// default option is by address
 /// The API key can be obtained from https://cronoscan.com
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_erc721_transfer_history_blocking(
-    ::rust::String address, ::rust::String contract_address,
-    ::com::crypto::game_sdk::QueryOption option, ::rust::String api_key);
-
-/// given the BlockScout REST API base url and the account address
-/// (hexadecimal), it will return the list of all owned tokens (ref:
-/// https://cronos.org/explorer/testnet3/api-docs)
-::rust::Vec<::com::crypto::game_sdk::RawTokenResult>
-get_tokens_blocking(::rust::String blockscout_base_url,
-                    ::rust::String account_address);
-
-/// given the BlockScout REST API base url and the account address (hexadecimal;
-/// required) and optional contract address (hexadecimal; optional -- it can be
-/// empty if the option is ByAddress), it will return all the token transfers
-/// (ERC20, ERC721... in the newer BlockScout releases, also ERC1155) (ref:
-/// https://cronos.org/explorer/testnet3/api-docs) NOTE: QueryOption::ByContract
-/// is not supported by BlockScout
-::rust::Vec<::com::crypto::game_sdk::RawTxDetail>
-get_token_transfers_blocking(::rust::String blockscout_base_url,
-                             ::rust::String address,
-                             ::rust::String contract_address,
-                             ::com::crypto::game_sdk::QueryOption option);
-
-/// given the BlockScout REST API base url and the contract address
-/// (hexadecimal),
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_erc721_transfer_history_blocking(::rust::String address, ::rust::String contract_address, ::com::crypto::game_sdk::QueryOption option, ::rust::String api_key);
+
+/// given the BlockScout REST API base url and the account address (hexadecimal),
+/// it will return the list of all owned tokens
+/// (ref: https://cronos.org/explorer/testnet3/api-docs)
+::rust::Vec<::com::crypto::game_sdk::RawTokenResult> get_tokens_blocking(::rust::String blockscout_base_url, ::rust::String account_address);
+
+/// given the BlockScout REST API base url and the account address (hexadecimal; required)
+/// and optional contract address (hexadecimal; optional -- it can be empty if the option is ByAddress),
+/// it will return all the token transfers (ERC20, ERC721... in the newer BlockScout
+/// releases, also ERC1155)
+/// (ref: https://cronos.org/explorer/testnet3/api-docs)
+/// NOTE: QueryOption::ByContract is not supported by BlockScout
+::rust::Vec<::com::crypto::game_sdk::RawTxDetail> get_token_transfers_blocking(::rust::String blockscout_base_url, ::rust::String address, ::rust::String contract_address, ::com::crypto::game_sdk::QueryOption option);
+
+/// given the BlockScout REST API base url and the contract address (hexadecimal),
 ///
 /// page: A nonnegative integer that represents the page number to be used for
 /// pagination. 'offset' must be provided in conjunction.
 ///
-/// offset: A nonnegative integer that represents the maximum number of records
-/// to return when paginating. 'page' must be provided in conjunction.
+/// offset: A nonnegative integer that represents the maximum number of records to
+/// return when paginating. 'page' must be provided in conjunction.
 ///
-/// it will return the list of owners and balances (sorting from largest to
-/// smallest), but no token ids.
+/// it will return the list of owners and balances (sorting from largest to smallest),
+/// but no token ids.
 ///
 /// (ref: https://cronos.org/explorer/api-docs#token)
 ///
 /// ::TIPS:: Use another functions to get more token/owner details, e.g.
 /// `get_tokens_blocking` to get owned tokens by account_address
-::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail>
-get_token_holders(::rust::String blockscout_base_url,
-                  ::rust::String contract_address, ::std::uint64_t page,
-                  ::std::uint64_t offset);
+::rust::Vec<::com::crypto::game_sdk::TokenHolderDetail> get_token_holders(::rust::String blockscout_base_url, ::rust::String contract_address, ::std::uint64_t page, ::std::uint64_t offset);
 
 /// it creates the payment object
 /// https://pay-docs.crypto.com/#api-reference-resources-payments-create-a-payment
 /// This API can be called using either your Secret Key or Publishable Key.
-/// The amount should be given in base units (e.g. for USD, the base unit is
-/// cents 1 USD == 100 cents).
-::com::crypto::game_sdk::CryptoComPaymentResponse
-create_payment(::rust::String secret_or_publishable_api_key,
-               ::rust::String base_unit_amount, ::rust::String currency,
-               ::com::crypto::game_sdk::OptionalArguments const &optional_args);
+/// The amount should be given in base units (e.g. for USD, the base unit is cents 1 USD == 100 cents).
+::com::crypto::game_sdk::CryptoComPaymentResponse create_payment(::rust::String secret_or_publishable_api_key, ::rust::String base_unit_amount, ::rust::String currency, ::com::crypto::game_sdk::OptionalArguments const &optional_args);
 
 /// it returns the payment object by id
 /// https://pay-docs.crypto.com/#api-reference-resources-payments-get-payment-by-id
 /// This API can be called using either your Secret Key or Publishable Key.
-::com::crypto::game_sdk::CryptoComPaymentResponse
-get_payment(::rust::String secret_or_publishable_api_key,
-            ::rust::String payment_id);
+::com::crypto::game_sdk::CryptoComPaymentResponse get_payment(::rust::String secret_or_publishable_api_key, ::rust::String payment_id);
 } // namespace game_sdk
 } // namespace crypto
 } // namespace com
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/nft.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/nft.h
index cda6bbd3..55a8d640 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/nft.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/nft.h
@@ -7,43 +7,43 @@ namespace defi_wallet_core {
 
 /// struct for efficient pagination
 struct Pagination {
-    /// Set true to enable the pagination
-    ///
-    /// A workaround filed for enabling pagination. It could be changed to
-    /// std::optional<Pagination> if https://github.com/dtolnay/cxx/issues/87
-    /// fixed
-    bool enable;
-    /// key is a value returned in PageResponse.next_key to begin
-    /// querying the next page most efficiently. Only one of offset or key
-    /// should be set.
-    rust::Vec<uint8_t> key;
-    /// offset is a numeric offset that can be used when key is
-    /// unavailable. It is less efficient than using key. Only
-    /// one of offset or key should be set.
-    uint64_t offset;
-    /// limit is the total number of results to be returned in the
-    /// result page. If left empty it will default to a value to be
-    /// set by each app.
-    uint64_t limit;
-    /// count_total is set to true  to indicate that the result set
-    /// should include a count of the total number of items available
-    /// for pagination in UIs. count_total is only respected when
-    /// offset is used. It is ignored when key is set.
-    bool count_total;
-    /// reverse is set to true if results are to be
-    /// returned in the descending order.
-    ///
-    /// Since: cosmos-sdk 0.43
-    bool reverse;
+  /// Set true to enable the pagination
+  ///
+  /// A workaround filed for enabling pagination. It could be changed to
+  /// std::optional<Pagination> if https://github.com/dtolnay/cxx/issues/87
+  /// fixed
+  bool enable;
+  /// key is a value returned in PageResponse.next_key to begin
+  /// querying the next page most efficiently. Only one of offset or key
+  /// should be set.
+  rust::Vec<uint8_t> key;
+  /// offset is a numeric offset that can be used when key is
+  /// unavailable. It is less efficient than using key. Only
+  /// one of offset or key should be set.
+  uint64_t offset;
+  /// limit is the total number of results to be returned in the
+  /// result page. If left empty it will default to a value to be
+  /// set by each app.
+  uint64_t limit;
+  /// count_total is set to true  to indicate that the result set
+  /// should include a count of the total number of items available
+  /// for pagination in UIs. count_total is only respected when
+  /// offset is used. It is ignored when key is set.
+  bool count_total;
+  /// reverse is set to true if results are to be
+  /// returned in the descending order.
+  ///
+  /// Since: cosmos-sdk 0.43
+  bool reverse;
 
-    Pagination();
+  Pagination();
 
-    bool get_enable() const;
-    rust::Vec<uint8_t> get_key() const;
-    uint64_t get_offset() const;
-    uint64_t get_limit() const;
-    bool get_count_total() const;
-    bool get_reverse() const;
+  bool get_enable() const;
+  rust::Vec<uint8_t> get_key() const;
+  uint64_t get_offset() const;
+  uint64_t get_limit() const;
+  bool get_count_total() const;
+  bool get_reverse() const;
 };
 
 } // namespace defi_wallet_core
diff --git a/Source/ThirdParty/PlayCppSdkLibrary/Include/rust/cxx.h b/Source/ThirdParty/PlayCppSdkLibrary/Include/rust/cxx.h
index 9da2c332..00228255 100644
--- a/Source/ThirdParty/PlayCppSdkLibrary/Include/rust/cxx.h
+++ b/Source/ThirdParty/PlayCppSdkLibrary/Include/rust/cxx.h
@@ -26,78 +26,79 @@ inline namespace cxxbridge1 {
 struct unsafe_bitcopy_t;
 
 namespace {
-template <typename T> class impl;
+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;
+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
 
@@ -105,62 +106,63 @@ class String final {
 #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;
+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;
+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
 
@@ -168,207 +170,214 @@ template <> struct copy_assignable_if<false> {
 template <typename T>
 class Slice final
     : private detail::copy_assignable_if<std::is_const<T>::value> {
-  public:
-    using value_type = T;
+public:
+  using value_type = T;
 
-    Slice() noexcept;
-    Slice(T *, std::size_t count) noexcept;
+  Slice() noexcept;
+  Slice(T *, std::size_t count) noexcept;
 
-    Slice &operator=(const Slice<T> &) &noexcept = default;
-    Slice &operator=(Slice<T> &&) &noexcept = default;
+  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 *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;
+  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;
+  // 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;
+  class iterator;
+  iterator begin() const noexcept;
+  iterator end() const noexcept;
 
-    void swap(Slice &) 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;
+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;
+  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;
+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;
+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;
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
 
-    explicit Box(const T &);
-    explicit Box(T &&);
+  explicit Box(const T &);
+  explicit Box(T &&);
 
-    Box &operator=(Box &&) &noexcept;
+  Box &operator=(Box &&) &noexcept;
 
-    const T *operator->() const noexcept;
-    const T &operator*() const noexcept;
-    T *operator->() noexcept;
-    T &operator*() 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 &&...);
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
 
-    void swap(Box &) noexcept;
+  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;
+  // 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;
+  T *into_raw() noexcept;
 
-    /* Deprecated */ using value_type = element_type;
+  /* Deprecated */ using value_type = element_type;
 
-  private:
-    class uninit;
-    class allocation;
-    Box(uninit) noexcept;
-    void drop() noexcept;
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
 
-    friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
-    T *ptr;
+  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;
+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;
+template <typename Signature>
+class Fn;
 
-  private:
-    Ret (*trampoline)(Args..., void *fn) noexcept;
-    void *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
 
@@ -376,21 +385,21 @@ template <typename Ret, typename... Args> class Fn<Ret(Args...)> final {
 #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;
+public:
+  Error(const Error &);
+  Error(Error &&) noexcept;
+  ~Error() noexcept override;
 
-    Error &operator=(const Error &) &;
-    Error &operator=(Error &&) &noexcept;
+  Error &operator=(const Error &) &;
+  Error &operator=(Error &&) &noexcept;
 
-    const char *what() const noexcept override;
+  const char *what() const noexcept override;
 
-  private:
-    Error() noexcept = default;
-    friend impl<Error>;
-    const char *msg;
-    std::size_t len;
+private:
+  Error() noexcept = default;
+  friend impl<Error>;
+  const char *msg;
+  std::size_t len;
 };
 #endif // CXXBRIDGE1_RUST_ERROR
 
@@ -410,15 +419,17 @@ std::ostream &operator<<(std::ostream &, const Str &);
 #define CXXBRIDGE1_RUST_OPAQUE
 // Base class of generated opaque Rust types.
 class Opaque {
-  public:
-    Opaque() = delete;
-    Opaque(const Opaque &) = delete;
-    ~Opaque() = delete;
+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();
+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.
@@ -438,7 +449,8 @@ template <typename T> std::size_t align_of();
 //      --- otherwise:
 //    + template <>
 //    + struct rust::IsRelocatable<MyType> : std::true_type {};
-template <typename T> struct IsRelocatable;
+template <typename T>
+struct IsRelocatable;
 
 using u8 = std::uint8_t;
 using u16 = std::uint16_t;
@@ -455,38 +467,46 @@ 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>;
+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>;
+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);
+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);
+  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;
+  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;
+  explicit unsafe_bitcopy_t() = default;
 };
 #endif // CXXBRIDGE1_RUST_BITCOPY_T
 
@@ -497,428 +517,485 @@ constexpr unsafe_bitcopy_t unsafe_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() 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>
+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>
+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>::size() const noexcept {
+  return sliceLen(this);
 }
 
-template <typename T> std::size_t Slice<T>::length() const noexcept {
-    return this->size();
+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>
+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>::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>::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>::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>
+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);
+  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);
+  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);
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  auto diff = std::distance(static_cast<char *>(other.pos),
+                            static_cast<char *>(this->pos));
+  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
+                    this->stride);
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
-    return this->pos == other.pos;
+  return this->pos == other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
-    return this->pos != other.pos;
+  return this->pos != other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
-    return this->pos < other.pos;
+  return this->pos < other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
-    return this->pos <= other.pos;
+  return this->pos <= other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
-    return this->pos > other.pos;
+  return this->pos > other.pos;
 }
 
 template <typename T>
 bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
-    return this->pos >= other.pos;
+  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;
+  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;
+  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);
+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);
-        }
+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;
+  }
+  T *ptr;
 };
 
-template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
-    other.ptr = nullptr;
+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(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(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() 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>
+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> 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> 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);
+  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>
+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>
+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>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
 }
 
-template <typename T> Box<T>::Box(uninit) noexcept {}
+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(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(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(Vec &&other) noexcept : repr(other.repr) {
+  new (&other) Vec();
 }
 
-template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }
+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=(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>
+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>
+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>
+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>());
+  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>::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>::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>
+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>::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>::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>::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>
+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>::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(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>
+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);
+  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>
+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>::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>::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();
+  return this->cbegin();
 }
 
 template <typename T>
 typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
-    return this->cend();
+  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();
+  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();
+  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);
+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.
@@ -941,57 +1018,69 @@ struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
 #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>
+  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 size_of() {
+  return layout::size_of<T>();
+}
 
-template <typename T> std::size_t align_of() { return layout::align_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>
+struct make_void {
+  using type = void;
+};
 
-template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
 
 template <typename Void, template <typename...> class, typename...>
 struct detect : std::false_type {};
@@ -1001,7 +1090,8 @@ 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>
+using detect_IsRelocatable = typename T::IsRelocatable;
 
 template <typename T>
 struct get_IsRelocatable