ton_sdk_client 1.7.1 → 1.13.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,33 +27,13 @@ module TonSdk
       INVALID_SIGNATURE = 122
     end
 
-    class ParamsOfFactorize
-      attr_reader :composite
-
-      def initialize(a)
-        @composite = a
-      end
-
+    ParamsOfFactorize = Struct.new(:composite) do
       def to_h = { composite: @composite }
     end
 
-    class ResultOfFactorize
-      attr_reader :factors
-
-      def initialize(a)
-        @factors = a
-      end
-    end
-
-    class ParamsOfModularPower
-      attr_reader :base, :exponent, :modulus
-
-      def initialize(base:, exponent:, modulus:)
-        @base = base
-        @exponent = exponent
-        @modulus = modulus
-      end
+    ResultOfFactorize = Struct.new(:factors)
 
+    ParamsOfModularPower = Struct.new(:base, :exponent, :modulus) do
       def to_h
         {
           base: @base,
@@ -63,84 +43,27 @@ module TonSdk
       end
     end
 
-    class ResultOfModularPower
-      attr_reader :modular_power
-
-      def initialize(a)
-        @modular_power = a
-      end
-    end
-
-    class ParamsOfTonCrc16
-      attr_reader :data
-
-      def initialize(a)
-        @data = a
-      end
+    ResultOfModularPower = Struct.new(:modular_power)
 
+    ParamsOfTonCrc16 = Struct.new(:data) do
       def to_h = { data: @data }
     end
 
-    class ResultOfTonCrc16
-      attr_reader :crc
-
-      def initialize(a)
-        @crc = a
-      end
-    end
-
-    class ParamsOfGenerateRandomBytes
-      attr_reader :length
-
-      def initialize(a)
-        @length = a
-      end
-
-      def to_h
-        {
-          length: @length
-        }
-      end
-    end
-
-    class ResultOfGenerateRandomBytes
-      attr_reader :bytes
+    ResultOfTonCrc16 = Struct.new(:crc)
 
-      def initialize(a)
-        @bytes = a
-      end
-    end
-
-    class ParamsOfConvertPublicKeyToTonSafeFormat
-      attr_reader :public_key
-
-      def initialize(a)
-        @public_key = a
-      end
-
-      def to_h
-        {
-          public_key: @public_key
-        }
-      end
+    ParamsOfGenerateRandomBytes = Struct.new(:length) do
+      def to_h = { length: @length }
     end
 
-    class ResultOfConvertPublicKeyToTonSafeFormat
-      attr_reader :ton_public_key
+    ResultOfGenerateRandomBytes = Struct.new(:bytes)
 
-      def initialize(a)
-        @ton_public_key = a
-      end
+    ParamsOfConvertPublicKeyToTonSafeFormat  = Struct.new(:public_key) do
+      def to_h = { public_key: @public_key }
     end
 
-    class KeyPair
-      attr_reader :public_, :secret
-
-      def initialize(public_: , secret:)
-        @public_ = public_
-        @secret = secret
-      end
+    ResultOfConvertPublicKeyToTonSafeFormat = Struct.new(:ton_public_key)
 
+    KeyPair = Struct.new(:public_, :secret) do
       def to_h
         {
           public: @public_,
@@ -149,14 +72,7 @@ module TonSdk
       end
     end
 
-    class ParamsOfSign
-      attr_reader :unsigned, :keys
-
-      def initialize(unsigned:, keys:)
-        @unsigned = unsigned
-        @keys = keys
-      end
-
+    ParamsOfSign = Struct.new(:unsigned, :keys) do
       def to_h
         {
           unsigned: @unsigned,
@@ -165,23 +81,9 @@ module TonSdk
       end
     end
 
-    class ResultOfSign
-      attr_reader :signed, :signature
-
-      def initialize(signed:, signature:)
-        @signed = signed
-        @signature = signature
-      end
-    end
-
-    class ParamsOfVerifySignature
-      attr_reader :signed, :public_
-
-      def initialize(signed:, public_:)
-        @signed = signed
-        @public_ = public_
-      end
+    ResultOfSign = Struct.new(:signed, :signature)
 
+    ParamsOfVerifySignature = Struct.new(:signed, :public_) do
       def to_h
         {
           signed: @signed,
@@ -190,48 +92,15 @@ module TonSdk
       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
+    ResultOfVerifySignature = Struct.new(:unsigned)
 
-      def initialize(a)
-        @hash = a
-      end
+    ParamsOfHash = Struct.new(:data) do
+      def to_h = { data: @data }
     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
+    ResultOfHash = Struct.new(:hash)
 
+    ParamsOfScrypt = Struct.new(:password, :salt, :log_n, :r, :p_, :dk_len) do
       def to_h
         {
           password: @password,
@@ -244,32 +113,13 @@ module TonSdk
       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
+    ResultOfScrypt = Struct.new(:key)
 
+    ParamsOfNaclSignKeyPairFromSecret = Struct.new(:secret) do
       def to_h = { secret: @secret }
     end
 
-    class ParamsOfNaclSign
-      attr_reader :unsigned, :secret
-
-      def initialize(unsigned:, secret:)
-        @unsigned = unsigned
-        @secret = secret
-      end
-
+    ParamsOfNaclSign = Struct.new(:unsigned, :secret) do
       def to_h
         {
           unsigned: @unsigned,
@@ -278,13 +128,7 @@ module TonSdk
       end
     end
 
-    class ResultOfNaclSign
-      attr_reader :signed
-
-      def initialize(a)
-        @signed = a
-      end
-    end
+    ResultOfNaclSign = Struct.new(:signed)
 
     class ParamsOfNaclSignOpen
       attr_reader :signed, :public_
@@ -302,21 +146,9 @@ module TonSdk
       end
     end
 
-    class ResultOfNaclSignOpen
-      attr_reader :unsigned
+    ResultOfNaclSignOpen = Struct.new(:unsigned)
 
-      def initialize(a)
-        @unsigned = a
-      end
-    end
-
-    class ResultOfNaclSignDetached
-      attr_reader :signature
-
-      def initialize(a)
-        @signature = a
-      end
-    end
+    ResultOfNaclSignDetached = Struct.new(:signature)
 
     class ParamsOfNaclBoxKeyPairFromSecret
       attr_reader :secret
@@ -352,13 +184,7 @@ module TonSdk
       end
     end
 
-    class ResultOfNaclBox
-      attr_reader :encrypted
-
-      def initialize(a)
-        @encrypted = a
-      end
-    end
+    ResultOfNaclBox = Struct.new(:encrypted)
 
     class ParamsOfNaclBoxOpen
       attr_reader :encrypted, :nonce, :their_public, :secret
@@ -380,13 +206,7 @@ module TonSdk
       end
     end
 
-    class ResultOfNaclBoxOpen
-      attr_reader :decrypted
-
-      def initialize(a)
-        @decrypted = a
-      end
-    end
+    ResultOfNaclBoxOpen = Struct.new(:decrypted)
 
     class ParamsOfNaclSecretBox
       attr_reader :decrypted, :nonce, :key
@@ -438,13 +258,7 @@ module TonSdk
       end
     end
 
-    class ResultOfMnemonicWords
-      attr_reader :words
-
-      def initialize(a)
-        @words = a
-      end
-    end
+    ResultOfMnemonicWords = Struct.new(:words)
 
     class ParamsOfMnemonicFromRandom
       attr_reader :dictionary, :word_count
@@ -462,13 +276,7 @@ module TonSdk
       end
     end
 
-    class ResultOfMnemonicFromRandom
-      attr_reader :phrase
-
-      def initialize(a)
-        @phrase = a
-      end
-    end
+    ResultOfMnemonicFromRandom = Struct.new(:phrase)
 
     class ParamsOfMnemonicFromEntropy
       attr_reader :entropy, :dictionary, :word_count
@@ -488,13 +296,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
@@ -514,13 +316,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

data/lib/ton_sdk_client/debot.rb

@@ -1,7 +1,7 @@
 module TonSdk
 
   # NOTE
-  # as of 3 feb 2021, in the main repository this module is still unstable
+  # as of 28 apr 2021, in the main repository this module is still unstable
   module Debot
 
     #
@@ -19,20 +19,11 @@ module TonSdk
       GET_METHOD_FAILED = 808
       INVALID_MSG = 809
       EXTERNAL_CALL_FAILED = 810
+      BROWSER_CALLBACK_FAILED = 811
+      OPERATION_REJECTED = 812
     end
 
-    class DebotAction
-      attr_reader :description, :name, :action_type, :to, :attributes, :misc
-
-      def initialize(description:, name:, action_type:, to:, attributes:, misc:)
-        @description = description
-        @name = name
-        @action_type = action_type
-        @to = to
-        @attributes = attributes
-        @misc = misc
-      end
-
+    DebotAction = Struct.new(:description, :name, :action_type, :to, :attributes, :misc, keyword_init: true) do
       def to_h
         {
           description: @description,
@@ -58,23 +49,11 @@ module TonSdk
       end
     end
 
-    class ParamsOfStart
-      attr_reader :address
-
-      def initialize(a)
-        @address = a
-      end
-
-      def to_h = { address: @address }
+    ParamsOfStart = Struct.new(:debot_handle) do
+      def to_h = { debot_handle: @debot_handle }
     end
 
-    class RegisteredDebot
-      attr_reader :debot_handle
-
-      def initialize(a)
-        @debot_handle = a
-      end
-
+    RegisteredDebot = Struct.new(:debot_handle) do
       def to_h = { debot_handle: @debot_handle }
     end
 
@@ -171,42 +150,33 @@ module TonSdk
     end
 
     class ResultOfAppDebotBrowser
-      TYPE_VALUES = [
-        :input,
-        :get_signing_box,
-        :invoke_debot
-      ]
+      attr_reader :type_, :value, :signing_box, :is_approved
 
-      attr_reader :type_, :value, :signing_box
+      def new_with_type_input(a)
+        @type_ = :input
+        @value = a
+      end
 
-      def initialize(type_:, value: nil, signing_box: nil)
-        unless TYPE_VALUES.include?(type_)
-          raise ArgumentError.new("type #{type_} is unknown; known types: #{TYPE_VALUES}")
-        end
-        @type_ = type_
-        @value = value
+      def new_with_type_get_signing_box(a)
+        @type_ = :get_signing_box
         @signing_box = signing_box
       end
-    end
 
-    class ParamsOfFetch
-      attr_reader :address
+      def new_with_type_invoke_debot
+        @type_ = :invoke_debot
+      end
 
-      def initialize(a)
-        @address = a
+      def new_with_type_approve(a)
+        @type_ = :approve
+        @is_approved = a
       end
+    end
 
+    ParamsOfFetch = Struct.new(:address) do
       def to_h = { address: @address }
     end
 
-    class ParamsOfExecute
-      attr_reader :debot_handle, :action
-
-      def initialize(debot_handle:, action:)
-        @debot_handle = debot_handle
-        @action = action
-      end
-
+    ParamsOfExecute = Struct.new(:debot_handle, :action) do
       def to_h
         {
           debot_handle: @debot_handle,
@@ -215,14 +185,7 @@ module TonSdk
       end
     end
 
-    class ParamsOfSend
-      attr_reader :debot_handle, :message
-
-      def initialize(debot_handle:, message:)
-        @debot_handle = debot_handle
-        @message = message
-      end
-
+    ParamsOfSend = Struct.new(:debot_handle, :message) do
       def to_h
         {
           debot_handle: @debot_handle,
@@ -231,99 +194,52 @@ module TonSdk
       end
     end
 
+    ParamsOfInit = Struct.new(:address)
+
+    DebotInfo = Struct.new(
+      :name,
+      :version,
+      :publisher,
+      :key,
+      :author,
+      :support,
+      :hello,
+      :language,
+      :dabi,
+      :icon,
+      :interfaces,
+      keyword_init: true
+    )
+
+    ResultOfFetch = Struct.new(:info)
+
+
     #
     # functions
     #
 
-    def self.start(ctx, params, app_browser_obj)
-      # TODO
-      # 1) the handlers in 'start' and 'fetch' are identical
-      # verify that it works and get rid of repetition
-
-      # 2) this all can be replaced with 'app_browser_obj.request(...)' and 
-      # 'app_browser_obj.notify(...)' calls, possibly
-
-      app_resp_handler = Proc.new do |data|
-        req_data = data["request_data"]
-        case data["type"]
-        when "Log"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          app_browser_obj.log(new_obj.msg)
-
-        when "Switch"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          app_browser_obj.switch_to(new_obj.context_id)
-
-        when "SwitchCompleted"
-          app_browser_obj.switch_completed()
-
-        when "ShowAction"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          app_browser_obj.show_action(new_obj.action)
-
-        when "Input"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          # TODO possibly in a new thread or fiber
-          app_req_res = begin
-            res = app_browser_obj.input(new_obj.prompt)
-            Client::AppRequestResult(type_: :ok, result: ResultOfAppDebotBrowser.new(type_: :input, value: res))
-          rescue Exception => e
-            Client::AppRequestResult(type_: :error, text: e.message)
-          end
-
-          params = Client::ParamsOfResolveAppRequest.new(
-            app_request_id: data["app_request_id"],
-            result: app_req_res
-          )
-          TonSdk::Client.resolve_app_request(c_ctx, params)
-
-        when "GetSigningBox"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          # TODO possibly in a new thread or fiber
-          app_req_res = begin
-            res = app_browser_obj.get_signing_box()
-            Client::AppRequestResult(type_: :ok, result: ResultOfAppDebotBrowser.new(type_: :get_signing_box, signing_box: res))
-          rescue Exception => e
-            Client::AppRequestResult(type_: :error, text: e.message)
-          end
-
-          params = Client::ParamsOfResolveAppRequest.new(
-            app_request_id: data["app_request_id"],
-            result: app_req_res
-          )
-          TonSdk::Client.resolve_app_request(c_ctx, params)
-
-        when "InvokeDebot"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          # TODO possibly in a new thread or fiber
-          app_req_res = begin
-            res = app_browser_obj.invoke_debot(new_obj.debot_addr, new_obj.action)
-            Client::AppRequestResult(type_: :ok, result: ResultOfAppDebotBrowser.new(type_: :invoke_debot))
-          rescue Exception => e
-            Client::AppRequestResult(type_: :error, text: e.message)
-          end
-
-          params = Client::ParamsOfResolveAppRequest.new(
-            app_request_id: data["app_request_id"],
-            result: app_req_res
+    def self.init(ctx, params, app_browser_obj)
+      Interop::request_to_native_lib(ctx, "debot.init", params.to_h.to_json) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: nil
           )
-          TonSdk::Client.resolve_app_request(c_ctx, params)
-
         else
-          # TODO log 'unknown option'
+          yield resp
         end
       end
+    end
 
+    def self.start(ctx, params)
       Interop::request_to_native_lib(
         ctx,
         "debot.start",
         params.to_h.to_json,
-        debot_app_response_handler: app_resp_handler,
         is_single_thread_only: false
       ) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
-            result: RegisteredDebot.new(resp.result["debot_handle"])
+            result: nil
           )
         else
           yield resp
@@ -331,95 +247,17 @@ module TonSdk
       end
     end
 
-    def self.fetch(ctx, params, app_browser_obj)
-      # TODO
-      # 1) the handlers in 'start' and 'fetch' are identical
-      # verify that it works and get rid of repetition
-
-      # 2) this all can be replaced with 'app_browser_obj.request(...)' and 
-      # 'app_browser_obj.notify(...)' calls, possibly
-
-      app_resp_handler = Proc.new do |data|
-        req_data = data["request_data"]
-        case data["type"]
-        when "Log"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          app_browser_obj.log(new_obj.msg)
-
-        when "Switch"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          app_browser_obj.switch_to(new_obj.context_id)
-
-        when "SwitchCompleted"
-          app_browser_obj.switch_completed()
-
-        when "ShowAction"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          app_browser_obj.show_action(new_obj.action)
-
-        when "Input"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          # TODO possibly in a new thread or fiber
-          app_req_res = begin
-            res = app_browser_obj.input(new_obj.prompt)
-            Client::AppRequestResult(type_: :ok, result: ResultOfAppDebotBrowser.new(type_: :input, value: res))
-          rescue Exception => e
-            Client::AppRequestResult(type_: :error, text: e.message)
-          end
-
-          params = Client::ParamsOfResolveAppRequest.new(
-            app_request_id: data["app_request_id"],
-            result: app_req_res
-          )
-          TonSdk::Client.resolve_app_request(c_ctx, params)
-
-        when "GetSigningBox"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          # TODO possibly in a new thread or fiber
-          app_req_res = begin
-            res = app_browser_obj.get_signing_box()
-            Client::AppRequestResult(type_: :ok, result: ResultOfAppDebotBrowser.new(type_: :get_signing_box, signing_box: res))
-          rescue Exception => e
-            Client::AppRequestResult(type_: :error, text: e.message)
-          end
-
-          params = Client::ParamsOfResolveAppRequest.new(
-            app_request_id: data["app_request_id"],
-            result: app_req_res
-          )
-          TonSdk::Client.resolve_app_request(c_ctx, params)
-
-        when "InvokeDebot"
-          new_obj = ParamsOfAppDebotBrowser.from_json(data)
-          # TODO possibly in a new thread or fiber
-          app_req_res = begin
-            res = app_browser_obj.invoke_debot(new_obj.debot_addr, new_obj.action)
-            Client::AppRequestResult(type_: :ok, result: ResultOfAppDebotBrowser.new(type_: :invoke_debot))
-          rescue Exception => e
-            Client::AppRequestResult(type_: :error, text: e.message)
-          end
-
-          params = Client::ParamsOfResolveAppRequest.new(
-            app_request_id: data["app_request_id"],
-            result: app_req_res
-          )
-          TonSdk::Client.resolve_app_request(c_ctx, params)
-
-        else
-          # TODO log 'unknown option'
-        end
-      end
-
+    def self.fetch(ctx, params)
       Interop::request_to_native_lib(
         ctx,
         "debot.fetch",
         params.to_h.to_json,
-        debot_app_response_handler: app_resp_handler,
         is_single_thread_only: false
       ) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
-            result: RegisteredDebot.new(resp.result["debot_handle"])
+            # TODO: parse DebotInfo
+            result: ResultOfFetch.new(resp.result["info"])
           )
         else
           yield resp