ton_sdk_client 1.12.0 → 1.17.0

data/lib/ton_sdk_client/crypto.rb

@@ -10,11 +10,11 @@ module TonSdk
       INVALID_KEY = 102
       INVALID_FACTORIZE_CHALLENGE = 106
       INVALID_BIGINT = 107
-      SCRYPT_FAILED = 108,
+      SCRYPT_FAILED = 108
       INVALID_KEYSIZE = 109
-      NACL_SECRET_BOX_FAILED = 110,
-      NACL_BOX_FAILED = 111,
-      NACL_SIGN_FAILED = 112,
+      NACL_SECRET_BOX_FAILED = 110
+      NACL_BOX_FAILED = 111
+      NACL_SIGN_FAILED = 112
       BIP39_INVALID_ENTROPY = 113
       BIP39_INVALID_PHRASE = 114
       BIP32_INVALID_KEY = 115
@@ -27,371 +27,71 @@ module TonSdk
       INVALID_SIGNATURE = 122
     end
 
-    class ParamsOfFactorize
-      attr_reader :composite
-
-      def initialize(a)
-        @composite = a
-      end
-
-      def to_h = { composite: @composite }
-    end
-
+    ParamsOfFactorize = Struct.new(:composite)
     ResultOfFactorize = Struct.new(:factors)
-
-    class ParamsOfModularPower
-      attr_reader :base, :exponent, :modulus
-
-      def initialize(base:, exponent:, modulus:)
-        @base = base
-        @exponent = exponent
-        @modulus = modulus
-      end
-
-      def to_h
-        {
-          base: @base,
-          exponent: @exponent,
-          modulus: @modulus
-        }
-      end
-    end
-
+    ParamsOfModularPower = Struct.new(:base, :exponent, :modulus, keyword_init: true)
     ResultOfModularPower = Struct.new(:modular_power)
-
-    ParamsOfTonCrc16 = Struct.new(:data) do
-      def to_h = { data: @data }
-    end
+    ParamsOfTonCrc16 = Struct.new(:data)
 
     ResultOfTonCrc16 = Struct.new(:crc)
-
-    ParamsOfGenerateRandomBytes = Struct.new(:length) do
-      def to_h = { length: @length }
-    end
-
+    ParamsOfGenerateRandomBytes = Struct.new(:length)
     ResultOfGenerateRandomBytes = Struct.new(:bytes)
-
-    ParamsOfConvertPublicKeyToTonSafeFormat  = Struct.new(:public_key) do
-      def to_h = { public_key: @public_key }
-    end
-
+    ParamsOfConvertPublicKeyToTonSafeFormat  = Struct.new(:public_key)
     ResultOfConvertPublicKeyToTonSafeFormat = Struct.new(:ton_public_key)
 
-    KeyPair = Struct.new(:public_, :secret) do
-      def to_h
-        {
-          public: @public_,
-          secret: @secret
-        }
-      end
-    end
-
-    ParamsOfSign = Struct.new(:unsigned, :keys) do
-      def to_h
-        {
-          unsigned: @unsigned,
-          keys: @keys.to_h
-        }
-      end
-    end
-
+    KeyPair = Struct.new(:public_, :secret)
+    ParamsOfSign = Struct.new(:unsigned, :keys)
     ResultOfSign = Struct.new(:signed, :signature)
-
-    class ParamsOfVerifySignature
-      attr_reader :signed, :public_
-
-      def initialize(signed:, public_:)
-        @signed = signed
-        @public_ = public_
-      end
-
-      def to_h
-        {
-          signed: @signed,
-          public: @public_
-        }
-      end
-    end
-
-    class ResultOfVerifySignature
-      attr_reader :unsigned
-
-      def initialize(a)
-        @unsigned = a
-      end
-    end
-
-    class ParamsOfHash
-      attr_reader :data
-
-      def initialize(a)
-        @data = a
-      end
-
-      def to_h
-        {
-          data: @data
-        }
-      end
-    end
-
-    class ResultOfHash
-      attr_reader :hash
-
-      def initialize(a)
-        @hash = a
-      end
-    end
-
-    class ParamsOfScrypt
-      attr_reader :password, :salt, :log_n, :r, :p_, :dk_len
-
-      def initialize(password:, salt:, log_n:, r:, p_:, dk_len:)
-        @password = password
-        @salt = salt
-        @log_n = log_n
-        @r = r
-        @p_ = p_
-        @dk_len = dk_len
-      end
-
-      def to_h
-        {
-          password: @password,
-          salt: @salt,
-          log_n: @log_n,
-          r: @r,
-          p: @p_,
-          dk_len: @dk_len
-        }
-      end
-    end
-
-    class ResultOfScrypt
-      attr_reader :key
-
-      def initialize(a)
-        @key = a
-      end
-    end
-
-    class ParamsOfNaclSignKeyPairFromSecret
-      attr_reader :secret
-
-      def initialize(a)
-        @secret = a
-      end
-
-      def to_h = { secret: @secret }
-    end
-
-    class ParamsOfNaclSign
-      attr_reader :unsigned, :secret
-
-      def initialize(unsigned:, secret:)
-        @unsigned = unsigned
-        @secret = secret
-      end
-
-      def to_h
-        {
-          unsigned: @unsigned,
-          secret: @secret
-        }
-      end
-    end
-
-    class ResultOfNaclSign
-      attr_reader :signed
-
-      def initialize(a)
-        @signed = a
-      end
-    end
-
-    class ParamsOfNaclSignOpen
-      attr_reader :signed, :public_
-
+    ParamsOfVerifySignature = Struct.new(:signed, :public_)
+    ResultOfVerifySignature = Struct.new(:unsigned)
+
+    ParamsOfHash = Struct.new(:data)
+    ResultOfHash = Struct.new(:hash)
+    ParamsOfScrypt = Struct.new(:password, :salt, :log_n, :r, :p_, :dk_len, keyword_init: true)
+    ResultOfScrypt = Struct.new(:key)
+    ParamsOfNaclSignKeyPairFromSecret = Struct.new(:secret)
+
+    ParamsOfNaclSign = Struct.new(:unsigned, :secret)
+    ResultOfNaclSign = Struct.new(:signed)
+    ParamsOfNaclSignOpen = Struct.new(:signed, :public_) do
       def initialize(signed:, public_:)
-        @signed = signed
-        @public_ = public_
-      end
-
-      def to_h
-        {
-          signed: @signed,
-          public: @public_
-        }
-      end
-    end
-
-    class ResultOfNaclSignOpen
-      attr_reader :unsigned
-
-      def initialize(a)
-        @unsigned = a
-      end
-    end
-
-    class ResultOfNaclSignDetached
-      attr_reader :signature
-
-      def initialize(a)
-        @signature = a
+        super
       end
     end
 
-    class ParamsOfNaclBoxKeyPairFromSecret
-      attr_reader :secret
-
-      def initialize(a)
-        @secret = a
-      end
-
-      def to_h
-        {
-          secret: @secret
-        }
-      end
-    end
-
-    class ParamsOfNaclBox
-      attr_reader :decrypted, :nonce, :their_public, :secret
-
+    ResultOfNaclSignOpen = Struct.new(:unsigned)
+    ResultOfNaclSignDetached = Struct.new(:signature)
+    ParamsOfNaclBoxKeyPairFromSecret = Struct.new(:secret)
+    ParamsOfNaclBox = Struct.new(:decrypted, :nonce, :their_public, :secret) do
       def initialize(decrypted:, nonce:, their_public:, secret:)
-        @decrypted = decrypted
-        @nonce = nonce
-        @their_public = their_public
-        @secret = secret
-      end
-
-      def to_h
-        {
-          decrypted: @decrypted,
-          nonce: @nonce,
-          their_public: @their_public,
-          secret: @secret
-        }
+        super
       end
     end
 
-    class ResultOfNaclBox
-      attr_reader :encrypted
-
-      def initialize(a)
-        @encrypted = a
-      end
-    end
-
-    class ParamsOfNaclBoxOpen
-      attr_reader :encrypted, :nonce, :their_public, :secret
-
+    ResultOfNaclBox = Struct.new(:encrypted)
+    ParamsOfNaclBoxOpen = Struct.new(:encrypted, :nonce, :their_public, :secret) do
       def initialize(encrypted:, nonce:, their_public:, secret:)
-        @encrypted = encrypted
-        @nonce = nonce
-        @their_public = their_public
-        @secret = secret
-      end
-
-      def to_h
-        {
-          encrypted: @encrypted,
-          nonce: @nonce,
-          their_public: @their_public,
-          secret: @secret
-        }
-      end
-    end
-
-    class ResultOfNaclBoxOpen
-      attr_reader :decrypted
-
-      def initialize(a)
-        @decrypted = a
+        super
       end
     end
 
-    class ParamsOfNaclSecretBox
-      attr_reader :decrypted, :nonce, :key
-
+    ResultOfNaclBoxOpen = Struct.new(:decrypted)
+    ParamsOfNaclSecretBox = Struct.new(:decrypted, :nonce, :key) do
       def initialize(decrypted:, nonce:, key:)
-        @decrypted = decrypted
-        @nonce = nonce
-        @key = key
-      end
-
-      def to_h
-        {
-          decrypted: @decrypted,
-          nonce: @nonce,
-          key: @key
-        }
+        super
       end
     end
 
-    class ParamsOfNaclSecretBoxOpen
-      attr_reader :encrypted, :nonce, :key
-
+    ParamsOfNaclSecretBoxOpen = Struct.new(:encrypted, :nonce, :key) do
       def initialize(encrypted:, nonce:, key:)
-        @encrypted = encrypted
-        @nonce = nonce
-        @key = key
-      end
-
-      def to_h
-        {
-          encrypted: @encrypted,
-          nonce: @nonce,
-          key: @key
-        }
+        super
       end
     end
 
-    class ParamsOfMnemonicWords
-      attr_reader :dictionary
-
-      def initialize(a: nil)
-        @dictionary = a
-      end
-
-      def to_h
-        {
-          dictionary: @dictionary
-        }
-      end
-    end
-
-    class ResultOfMnemonicWords
-      attr_reader :words
-
-      def initialize(a)
-        @words = a
-      end
-    end
-
-    class ParamsOfMnemonicFromRandom
-      attr_reader :dictionary, :word_count
-
-      def initialize(dictionary: nil, word_count: nil)
-        @dictionary = dictionary
-        @word_count = word_count
-      end
-
-      def to_h
-        {
-          dictionary: @dictionary,
-          word_count: @word_count
-        }
-      end
-    end
-
-    class ResultOfMnemonicFromRandom
-      attr_reader :phrase
-
-      def initialize(a)
-        @phrase = a
-      end
-    end
+    ParamsOfMnemonicWords = Struct.new(:dictionary)
+    ResultOfMnemonicWords = Struct.new(:words)
+    ParamsOfMnemonicFromRandom = Struct.new(:dictionary, :word_count, keyword_init: true)
+    ResultOfMnemonicFromRandom = Struct.new(:phrase)
 
     class ParamsOfMnemonicFromEntropy
       attr_reader :entropy, :dictionary, :word_count
@@ -411,13 +111,7 @@ module TonSdk
       end
     end
 
-    class ResultOfMnemonicFromEntropy
-      attr_reader :phrase
-
-      def initialize(a)
-        @phrase = a
-      end
-    end
+    ResultOfMnemonicFromEntropy = Struct.new(:phrase)
 
     class ParamsOfMnemonicVerify
       attr_reader :phrase, :dictionary, :word_count
@@ -437,13 +131,7 @@ module TonSdk
       end
     end
 
-    class ResultOfMnemonicVerify
-      attr_reader :valid
-
-      def initialize(a)
-        @valid = a
-      end
-    end
+    ResultOfMnemonicVerify = Struct.new(:valid)
 
     class ParamsOfMnemonicDeriveSignKeys
       attr_reader :phrase, :path, :dictionary, :word_count
@@ -483,13 +171,7 @@ module TonSdk
       end
     end
 
-    class ResultOfHDKeyXPrvFromMnemonic
-      attr_reader :xprv
-
-      def initialize(a)
-        @xprv = a
-      end
-    end
+    ResultOfHDKeyXPrvFromMnemonic = Struct.new(:xprv)
 
     class ParamsOfHDKeyDeriveFromXPrv
       attr_reader :xprv, :child_index, :hardened
@@ -509,162 +191,37 @@ module TonSdk
       end
     end
 
-    class ResultOfHDKeyDeriveFromXPrv
-      attr_reader :xprv
-
-      def initialize(a)
-        @xprv = a
-      end
-
-      def to_h
-        {
-          xprv: @xprv,
-          path: @path
-        }
-      end
-    end
-
-    class ParamsOfHDKeySecretFromXPrv
-      attr_reader :xprv
-
-      def initialize(a)
-        @xprv = a
-      end
-
-      def to_h
-        {
-          xprv: @xprv
-        }
-      end
-    end
-
-    class ResultOfHDKeySecretFromXPrv
-      attr_reader :secret
-
-      def initialize(a)
-        @secret = a
-      end
-    end
-
-    class ParamsOfHDKeyPublicFromXPrv
-      attr_reader :xprv
-
-      def initialize(a)
-        @xprv = a
-      end
-
-      def to_h
-        {
-          xprv: @xprv
-        }
-      end
-    end
-
-    class ResultOfHDKeyPublicFromXPrv
-      attr_reader :public_
-
-      def initialize(a)
-        @public_ = a
-      end
-    end
-
-    class ParamsOfHDKeyDeriveFromXPrvPath
-      attr_reader :xprv, :path
+    ResultOfHDKeyDeriveFromXPrv = Struct.new(:xprv)
+    ParamsOfHDKeySecretFromXPrv = Struct.new(:xprv)
+    ResultOfHDKeySecretFromXPrv = Struct.new(:secret)
+    ParamsOfHDKeyPublicFromXPrv = Struct.new(:xprv)
+    ResultOfHDKeyPublicFromXPrv = Struct.new(:public_)
 
+    ParamsOfHDKeyDeriveFromXPrvPath = Struct.new(:xprv, :path) do
       def initialize(xprv:, path:)
-        @xprv = xprv
-        @path = path
-      end
-
-      def to_h
-        {
-          xprv: @xprv,
-          path: @path
-        }
+        super
       end
     end
 
-    class ResultOfHDKeyDeriveFromXPrvPath
-      attr_reader :xprv
-
-      def initialize(a)
-        @xprv = a
-      end
-    end
-
-    class ParamsOfChaCha20
-      attr_reader :data, :key, :nonce
+    ResultOfHDKeyDeriveFromXPrvPath = Struct.new(:xprv)
 
+    ParamsOfChaCha20 = Struct.new(:data, :key, :nonce) do
       def initialize(data:, key:, nonce:)
-        @data = data
-        @key = key
-        @nonce = nonce
-      end
-
-      def to_h
-        {
-          data: @data,
-          key: @key,
-          nonce: @nonce
-        }
+        super
       end
     end
 
-    class ResultOfChaCha20
-      attr_reader :data
-
-      def initialize(a)
-        @data = a
-      end
-    end
-
-    class ParamsOfSigningBoxSign
-      attr_reader :signing_box, :unsigned
+    ResultOfChaCha20 = Struct.new(:data)
 
+    ParamsOfSigningBoxSign = Struct.new(:signing_box, :unsigned) do
       def initialize(signing_box:, unsigned:)
-        @signing_box = signing_box
-        @unsigned = unsigned
-      end
-
-      def to_h
-        {
-          signing_box: @signing_box,
-          unsigned: @unsigned
-        }
+        super
       end
     end
 
-    class ResultOfSigningBoxSign
-      attr_reader :signature
-
-      def initialize(a)
-        @signature = a
-      end
-    end
-
-    class RegisteredSigningBox
-      attr_reader :handle
-
-      def initialize(a)
-        @handle = a
-      end
-
-      def to_h
-        {
-          handle: @handle
-        }
-      end
-    end
-
-    class ResultOfSigningBoxGetPublicKey
-      attr_reader :pubkey
-
-      def initialize(a)
-        @pubkey = a
-      end
-
-      def to_h = { pubkey: @pubkey }
-    end
+    ResultOfSigningBoxSign = Struct.new(:signature)
+    RegisteredSigningBox = Struct.new(:handle)
+    ResultOfSigningBoxGetPublicKey = Struct.new(:pubkey)
 
     class ParamsOfNaclSignDetachedVerify
       attr_reader :unsigned, :signature, :public
@@ -682,15 +239,7 @@ module TonSdk
       end
     end
 
-    class ResultOfNaclSignDetachedVerify 
-      attr_reader :succeeded
-
-      def initialize(a)
-        @succeeded = a
-      end
-
-      def to_h = { succeeded: @succeeded }
-    end
+    ResultOfNaclSignDetachedVerify = Struct.new(:succeeded)
 
     class ParamsOfAppSigningBox
       TYPES = [
@@ -716,14 +265,18 @@ module TonSdk
       end
     end
 
+    EncryptionBoxInfo = Struct.new(:hdpath, :algorithm, :options, :public, keyword_init: true)
+    ParamsOfEncryptionBoxGetInfo = Struct.new(:encryption_box)
+    ResultOfEncryptionBoxGetInfo = Struct.new(:info)
+    RegisteredEncryptionBox = Struct.new(:handle)
+
 
     #
     # functions
     #
 
     def self.factorize(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.factorize", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.factorize", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfFactorize.new(resp.result["factors"])
@@ -735,8 +288,7 @@ module TonSdk
     end
 
     def self.modular_power(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.modular_power", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.modular_power", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfModularPower.new(resp.result["modular_power"])
@@ -748,8 +300,7 @@ module TonSdk
     end
 
     def self.ton_crc16(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.ton_crc16", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.ton_crc16", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfTonCrc16.new(resp.result["crc"])
@@ -761,8 +312,7 @@ module TonSdk
     end
 
     def self.generate_random_bytes(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.generate_random_bytes", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.generate_random_bytes", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfGenerateRandomBytes.new(resp.result["bytes"])
@@ -774,8 +324,7 @@ module TonSdk
     end
 
     def self.convert_public_key_to_ton_safe_format(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.convert_public_key_to_ton_safe_format", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.convert_public_key_to_ton_safe_format", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfConvertPublicKeyToTonSafeFormat.new(resp.result["ton_public_key"])
@@ -802,8 +351,7 @@ module TonSdk
     end
 
     def self.sign(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.sign", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.sign", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfSign.new(
@@ -818,8 +366,7 @@ module TonSdk
     end
 
     def self.verify_signature(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.verify_signature", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.verify_signature", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfVerifySignature.new(resp.result["unsigned"])
@@ -831,8 +378,7 @@ module TonSdk
     end
 
     def self.sha256(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.sha256", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.sha256", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfHash.new(resp.result["hash"])
@@ -844,8 +390,7 @@ module TonSdk
     end
 
     def self.sha512(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.sha512", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.sha512", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfHash.new(resp.result["hash"])
@@ -857,8 +402,7 @@ module TonSdk
     end
 
     def self.scrypt(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.scrypt", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.scrypt", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfScrypt.new(resp.result["key"])
@@ -870,8 +414,7 @@ module TonSdk
     end
 
     def self.nacl_sign_keypair_from_secret_key(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_keypair_from_secret_key", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_keypair_from_secret_key", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: KeyPair.new(public_: resp.result["public"], secret: resp.result["secret"])
@@ -883,8 +426,7 @@ module TonSdk
     end
 
     def self.nacl_sign(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_sign", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_sign", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfNaclSign.new(resp.result["signed"])
@@ -896,8 +438,7 @@ module TonSdk
     end
 
     def self.nacl_sign_open(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_open", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_open", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfNaclSignOpen.new(resp.result["unsigned"])
@@ -909,8 +450,7 @@ module TonSdk
     end
 
     def self.nacl_sign_detached(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_detached", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_detached", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfNaclSignDetached.new(resp.result["signature"])
@@ -921,8 +461,20 @@ module TonSdk
       end
     end
 
+    def self.nacl_sign_detached_verify(ctx, params)
+      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_detached_verify", params) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfNaclSignDetachedVerify.new(resp.result["succeeded"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
     def self.nacl_box_keypair(ctx)
-      Interop::request_to_native_lib(ctx, "crypto.nacl_box_keypair", "") do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_box_keypair") do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: KeyPair.new(public_: resp.result["public"], secret: resp.result["secret"])
@@ -934,8 +486,7 @@ module TonSdk
     end
 
     def self.nacl_box_keypair_from_secret_key(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_box_keypair_from_secret_key", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_box_keypair_from_secret_key", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: KeyPair.new(public_: resp.result["public"], secret: resp.result["secret"])
@@ -947,8 +498,7 @@ module TonSdk
     end
 
     def self.nacl_box(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_box", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_box", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfNaclBox.new(resp.result["encrypted"])
@@ -960,8 +510,7 @@ module TonSdk
     end
 
     def self.nacl_box_open(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_box_open", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_box_open", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfNaclBoxOpen.new(resp.result["decrypted"])
@@ -973,8 +522,7 @@ module TonSdk
     end
 
     def self.nacl_secret_box(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_secret_box", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_secret_box", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfNaclBox.new(resp.result["encrypted"])
@@ -986,8 +534,7 @@ module TonSdk
     end
 
     def self.nacl_secret_box_open(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.nacl_secret_box_open", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.nacl_secret_box_open", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfNaclBoxOpen.new(resp.result["decrypted"])
@@ -999,8 +546,7 @@ module TonSdk
     end
 
     def self.mnemonic_words(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.mnemonic_words", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.mnemonic_words", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfMnemonicWords.new(resp.result["words"])
@@ -1012,8 +558,7 @@ module TonSdk
     end
 
     def self.mnemonic_from_random(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.mnemonic_from_random", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.mnemonic_from_random", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfMnemonicFromRandom.new(resp.result["phrase"])
@@ -1025,8 +570,7 @@ module TonSdk
     end
 
     def self.mnemonic_from_entropy(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.mnemonic_from_entropy", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.mnemonic_from_entropy", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfMnemonicFromEntropy.new(resp.result["phrase"])
@@ -1038,8 +582,7 @@ module TonSdk
     end
 
     def self.mnemonic_verify(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.mnemonic_verify", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.mnemonic_verify", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfMnemonicVerify.new(resp.result["valid"])
@@ -1051,8 +594,7 @@ module TonSdk
     end
 
     def self.mnemonic_derive_sign_keys(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.mnemonic_derive_sign_keys", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.mnemonic_derive_sign_keys", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: KeyPair.new(public_: resp.result["public"], secret: resp.result["secret"])
@@ -1064,8 +606,7 @@ module TonSdk
     end
 
     def self.hdkey_xprv_from_mnemonic(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.hdkey_xprv_from_mnemonic", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.hdkey_xprv_from_mnemonic", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfHDKeyXPrvFromMnemonic.new(resp.result["xprv"])
@@ -1077,8 +618,7 @@ module TonSdk
     end
 
     def self.hdkey_derive_from_xprv(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.hdkey_derive_from_xprv", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.hdkey_derive_from_xprv", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfHDKeyDeriveFromXPrv.new(resp.result["xprv"])
@@ -1090,8 +630,7 @@ module TonSdk
     end
 
     def self.hdkey_derive_from_xprv_path(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.hdkey_derive_from_xprv_path", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.hdkey_derive_from_xprv_path", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfHDKeyDeriveFromXPrvPath.new(resp.result["xprv"])
@@ -1103,8 +642,7 @@ module TonSdk
     end
 
     def self.hdkey_secret_from_xprv(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.hdkey_secret_from_xprv", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.hdkey_secret_from_xprv", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfHDKeySecretFromXPrv.new(resp.result["secret"])
@@ -1116,8 +654,7 @@ module TonSdk
     end
 
     def self.hdkey_public_from_xprv(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.hdkey_public_from_xprv", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.hdkey_public_from_xprv", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfHDKeyPublicFromXPrv.new(resp.result["public"])
@@ -1129,8 +666,7 @@ module TonSdk
     end
 
     def self.chacha20(ctx, params)
-      pr_json = params.to_h.to_json
-      Interop::request_to_native_lib(ctx, "crypto.chacha20", pr_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.chacha20", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfChaCha20.new(resp.result["data"])
@@ -1181,7 +717,7 @@ module TonSdk
     end
 
     def self.get_signing_box(ctx, params)
-      Interop::request_to_native_lib(ctx, "crypto.get_signing_box", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.get_signing_box", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: RegisteredSigningBox.new(resp.result["handle"])
@@ -1196,7 +732,6 @@ module TonSdk
       Interop::request_to_native_lib(
         ctx,
         "crypto.signing_box_get_public_key",
-        params.to_h.to_json,
         is_single_thread_only: is_single_thread_only
       ) do |resp|
         if resp.success?
@@ -1210,7 +745,7 @@ module TonSdk
     end
 
     def self.signing_box_sign(ctx, params)
-      Interop::request_to_native_lib(ctx, "crypto.signing_box_sign", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.signing_box_sign", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfSigningBoxSign.new(resp.result["signature"])
@@ -1222,10 +757,10 @@ module TonSdk
     end
 
     def self.remove_signing_box(ctx, params)
-      Interop::request_to_native_lib(ctx, "crypto.remove_signing_box", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "crypto.remove_signing_box", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
-            result: ResultOfSigningBoxSign.new(resp.result["signature"])
+            result: nil
           )
         else
           yield resp
@@ -1233,11 +768,51 @@ module TonSdk
       end
     end
 
-    def self.nacl_sign_detached_verify(ctx, params)
-      Interop::request_to_native_lib(ctx, "crypto.nacl_sign_detached_verify", params.to_h.to_json) do |resp|
+    def self.register_encryption_box(ctx, app_obj:)
+      client_callback = Proc.new do |type_, x|
+        app_res = app_obj.request(x["request_data"])
+        app_req_result = case app_res
+        in [:success, result]
+          TonSdk::Client::AppRequestResult.new(
+            type_: :ok,
+            result: result
+          )
+        in [:error, text]
+          TonSdk::Client::AppRequestResult.new(
+            type_: :error,
+            text: text
+          )
+        end
+
+        params = TonSdk::Client::ParamsOfResolveAppRequest.new(
+          app_request_id: x["app_request_id"],
+          result: app_req_result
+        )
+        TonSdk::Client.resolve_app_request(ctx, params)
+      end
+
+      Interop::request_to_native_lib(
+        ctx,
+        "crypto.register_encryption_box",
+        nil,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
-            result: ResultOfNaclSignDetachedVerify.new(resp.result["succeeded"])
+            result: RegisteredEncryptionBox.new(resp.result["handle"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.encryption_box_get_info(ctx, params)
+      Interop::request_to_native_lib(ctx, "crypto.encryption_box_get_info", params) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfEncryptionBoxGetInfo.new(resp.result["info"])
           )
         else
           yield resp