ton_sdk_client 1.12.0 → 1.17.0

data/lib/ton_sdk_client/debot.rb

@@ -23,15 +23,15 @@ module TonSdk
       OPERATION_REJECTED = 812
     end
 
-    DebotAction = Struct.new(:description, :name, :action_type, :to, :attributes, :misc) do
+    DebotAction = Struct.new(:description, :name, :action_type, :to, :attributes, :misc, keyword_init: true) do
       def to_h
         {
-          description: @description,
-          name: @name,
-          action_type: @action_type,
-          to: @to,
-          attributes: @attributes,
-          misc: @misc
+          description: self.description,
+          name: self.name,
+          action_type: self.action_type,
+          to: self.to,
+          attributes: self.attributes,
+          misc: self.misc
         }
       end
 
@@ -49,15 +49,18 @@ module TonSdk
       end
     end
 
-    ParamsOfStart = Struct.new(:debot_handle) do
-      def to_h = { debot_handle: @debot_handle }
-    end
+    ParamsOfStart = Struct.new(:debot_handle)
 
-    RegisteredDebot = Struct.new(:debot_handle) do
-      def to_h = { debot_handle: @debot_handle }
+    RegisteredDebot = Struct.new(:debot_handle, :debot_abi, :info) do
+      def to_h = {
+        debot_handle: @debot_handle,
+        debot_abi: @debot_abi,
+        info: @info.to_h
+      }
     end
 
     class ParamsOfAppDebotBrowser
+      private_class_method :new
 
       # todo remove?
       TYPE_VALUES = [
@@ -68,50 +71,56 @@ module TonSdk
         :input,
         :get_signing_box,
         :invoke_debot,
-        :send
+        :send,
+        :approve
       ]
 
-      attr_reader :type_, :msg, :context_id, :action, :prompt, :debot_addr, :message
+      attr_reader :type_, :msg, :context_id, :action, :prompt, :debot_addr, :message, :activity
 
-      def new_with_type_log(msg)
+      def self.new_with_type_log(msg)
         @type_ = :log
         @msg = msg
       end
 
-      def new_with_type_switch(context_id)
+      def self.new_with_type_switch(context_id)
         @type_ = :switch
         @context_id = context_id
       end
 
-      def new_with_type_switch_completed
+      def self.new_with_type_switch_completed
         @type_ = :switch_completed
       end
 
-      def new_with_type_show_action(action)
+      def self.new_with_type_show_action(action)
         @type_ = :show_action
         @action = action
       end
 
-      def new_with_type_input(prompt)
+      def self.new_with_type_input(prompt)
         @type_ = :input
         @prompt = prompt
       end
 
-      def new_with_type_get_signing_box
+      def self.new_with_type_get_signing_box
         @type_ = :get_signing_box
       end
 
-      def new_with_type_invoke_debot(debot_addr, action)
+      def self.new_with_type_invoke_debot(debot_addr, action)
         @type_ = :invoke_debot
         @debot_addr = debot_addr
         @action = action
       end
 
-      def new_with_type_send(message)
+      def self.new_with_type_send(message)
         @type_ = :send
         @message = message
       end
 
+      def self.new_with_type_approve(activity)
+        @type_ = :approve
+        @activity = activity
+      end
+
       def to_h
         {
           type: Helper.sym_to_capitalized_case_str(@type_),
@@ -127,14 +136,38 @@ module TonSdk
       def self.from_json(j)
         return nil if j.nil?
 
-        self.new(
-          type_: self.parse_type(j["type"]),
-          msg: j["msg"],
-          context_id: j["context_id"],
-          action: DebotAction.from_json(j["action"]),
-          prompt: j["prompt"],
-          debot_addr: j["debot_addr"]
-        )
+        tp = self.parse_type(j["type"])
+        case tp
+        when :log
+          self.new_with_type_log(j["msg"])
+
+        when :switch
+          self.new_with_type_switch(j["context_id"])
+
+        when :switch_completed
+          self.new_with_type_switch_completed
+
+        when :show_action
+          self.new_with_type_show_action(DebotAction.from_json(j["action"]))
+
+        when :input
+          self.new_with_type_input(j["prompt"])
+
+        when :get_signing_box
+          self.new_with_type_get_signing_box
+
+        when :invoke_debot
+          self.new_with_type_invoke_debot(j["debot_addr"], DebotAction.from_json(j["action"]))
+
+        when :send
+          self.new_with_type_send(j["message"])
+
+        when :approve
+          self.new_with_type_send(DebotActivity.from_json(j["activity"]))
+
+        else
+          raise ArgumentError.new("no handler for type: #{tp}")
+        end
       end
 
       private
@@ -150,31 +183,31 @@ module TonSdk
     end
 
     class ResultOfAppDebotBrowser
+      private_class_method :new
+
       attr_reader :type_, :value, :signing_box, :is_approved
 
-      def new_with_type_input(a)
+      def self.new_with_type_input(a)
         @type_ = :input
         @value = a
       end
 
-      def new_with_type_get_signing_box(a)
+      def self.new_with_type_get_signing_box(a)
         @type_ = :get_signing_box
         @signing_box = signing_box
       end
 
-      def new_with_type_invoke_debot
+      def self.new_with_type_invoke_debot
         @type_ = :invoke_debot
       end
 
-      def new_with_type_approve(a)
+      def self.new_with_type_approve(a)
         @type_ = :approve
         @is_approved = a
       end
     end
 
-    ParamsOfFetch = Struct.new(:address) do
-      def to_h = { address: @address }
-    end
+    ParamsOfFetch = Struct.new(:address)
 
     ParamsOfExecute = Struct.new(:debot_handle, :action) do
       def to_h
@@ -185,22 +218,13 @@ module TonSdk
       end
     end
 
-    ParamsOfSend = Struct.new(:debot_handle, :message) do
-      def to_h
-        {
-          debot_handle: @debot_handle,
-          message: @message
-        }
-      end
-    end
-
+    ParamsOfSend = Struct.new(:debot_handle, :message)
     ParamsOfInit = Struct.new(:address)
-
     DebotInfo = Struct.new(
       :name,
       :version,
       :publisher,
-      :key,
+      :caption,
       :author,
       :support,
       :hello,
@@ -209,9 +233,48 @@ module TonSdk
       :icon,
       :interfaces,
       keyword_init: true
-    )
+    ) do
+      def initialize(
+        name: nil,
+        version: nil,
+        publisher: nil,
+        caption: nil,
+        author: nil,
+        support: nil,
+        hello: nil,
+        language: nil,
+        dabi: nil,
+        icon: nil,
+        interfaces: []
+      )
+        super
+      end
+    end
 
     ResultOfFetch = Struct.new(:info)
+    Spending = Struct.new(:amount, :dst)
+
+    class DebotActivity
+      private_class_method :new
+
+      attr_reader :type_, :msg, :dst, :out, :fee, :setcode, :signkey, :signing_box_handle
+
+      def self.new_with_type_transaction(msg:, dst:, out:, fee:, setcode:, signkey:, signing_box_handle:)
+        @type_ = :transaction
+        @msg = msg
+        @dst = dst
+        @out = out
+        @fee = fee
+        @setcode = setcode
+        @signkey = signkey
+        @signing_box_handle = signing_box_handle
+      end
+
+      def self.from_json(j)
+        # todo
+      end
+    end
+
 
 
     #
@@ -219,7 +282,7 @@ module TonSdk
     #
 
     def self.init(ctx, params, app_browser_obj)
-      Interop::request_to_native_lib(ctx, "debot.init", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "debot.init", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: nil
@@ -234,7 +297,7 @@ module TonSdk
       Interop::request_to_native_lib(
         ctx,
         "debot.start",
-        params.to_h.to_json,
+        params,
         is_single_thread_only: false
       ) do |resp|
         if resp.success?
@@ -251,7 +314,7 @@ module TonSdk
       Interop::request_to_native_lib(
         ctx,
         "debot.fetch",
-        params.to_h.to_json,
+        params,
         is_single_thread_only: false
       ) do |resp|
         if resp.success?
@@ -266,7 +329,7 @@ module TonSdk
     end
 
     def self.execute(ctx, params)
-      Interop::request_to_native_lib(ctx, "debot.execute", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "debot.execute", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: nil
@@ -278,7 +341,7 @@ module TonSdk
     end
 
     def self.remove(ctx, params)
-      Interop::request_to_native_lib(ctx, "debot.remove", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "debot.remove", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: nil
@@ -290,7 +353,7 @@ module TonSdk
     end
 
     def self.send(ctx, params)
-      Interop::request_to_native_lib(ctx, "debot.send", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "debot.send", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: nil

data/lib/ton_sdk_client/interop.rb

@@ -132,12 +132,12 @@ module TonSdk
     def self.request_to_native_lib(
       ctx,
       function_name,
-      function_params_json = nil,
+      function_params = nil,
       client_callback: nil,
       is_single_thread_only: true
     )
       function_name_tc_str = TcStringData.from_string(function_name)
-      function_params_json_str = function_params_json || ""
+      function_params_json_str = function_params&.to_h.to_json || ""
       function_params_json_tc_str = TcStringData.from_string(function_params_json_str)
 
       @sm = Concurrent::Semaphore.new(1)

data/lib/ton_sdk_client/net.rb

@@ -18,7 +18,7 @@ module TonSdk
       WEBSOCKET_DISCONNECTED = 610
       NOT_SUPPORTED = 611
       NO_ENDPOINTS_PROVIDED = 612
-      GRAPHQL_WEBSOCKET_INIT_ERROR = 613,
+      GRAPHQL_WEBSOCKET_INIT_ERROR = 613
       NETWORK_MODULE_RESUMED = 614
     end
 
@@ -37,20 +37,15 @@ module TonSdk
       end
     end
 
-    class ParamsOfQueryCollection
-      attr_reader :collection, :filter, :result, :order, :limit
-
+    ParamsOfQueryCollection = Struct.new(:collection, :filter, :result, :order, :limit, keyword_init: true) do
       def initialize(collection: , filter: nil, result: , order: [], limit: nil)
-        @collection = collection
-        @filter = filter
-        @result = result
-        @order = order
-        @limit = limit
+        super
       end
 
       def to_h
-        ord_h_s = if !@order.nil?
-          @order.map do |x|
+        h = super
+        ord_h_s = if !self.order.nil?
+          self.order.map do |x|
             {
               path: x.path,
               direction: x.direction.to_s.upcase
@@ -58,150 +53,63 @@ module TonSdk
           end
         end
 
-        {
-          collection: @collection,
-          filter: @filter,
-          result: @result,
-          order: ord_h_s,
-          limit: @limit
-        }
-      end
-    end
-
-    class ResultOfQueryCollection
-      attr_reader :result
-
-      def initialize(a)
-        @result = a
+        h[:order] = ord_h_s
+        h
       end
     end
 
-    class ParamsOfWaitForCollection
-      attr_reader :collection, :filter, :result, :timeout
-
+    ResultOfQueryCollection = Struct.new(:result)
+    ResultOfWaitForCollection = Struct.new(:result)
+    ResultOfQuery = Struct.new(:result)
+    ResultOfBatchQuery = Struct.new(:results)
+    ParamsOfWaitForCollection = Struct.new(:collection, :filter, :result, :timeout, keyword_init: true) do
       def initialize(collection:, filter: nil, result:, timeout: nil)
-        @collection = collection
-        @filter = filter
-        @result = result
-        @timeout = timeout
-      end
-
-      def to_h
-        {
-          collection: @collection,
-          filter: @filter,
-          result: @result,
-          timeout: @timeout
-        }
+        super
       end
     end
 
-    class ResultOfWaitForCollection
-      attr_reader :result
-
-      def initialize(a)
-        @result = a
-      end
-    end
-
-    class ParamsOfSubscribeCollection
-      attr_reader :collection, :filter, :result
-
+    ParamsOfSubscribeCollection = Struct.new(:collection, :filter, :result, keyword_init: true) do
       def initialize(collection:, filter: nil, result:)
-        @collection = collection
-        @filter = filter
-        @result = result
-      end
-
-      def to_h
-        {
-          collection: @collection,
-          filter: @filter,
-          result: @result
-        }
-      end
-    end
-
-    class ResultOfSubscribeCollection
-      attr_reader :handle
-
-      def initialize(a)
-        @handle = a
+        super
       end
-
-      def to_h = { handle: @handle }
     end
 
-    class ParamsOfQuery
-      attr_reader :query, :variables
-
+    ResultOfSubscribeCollection = Struct.new(:handle)
+    ParamsOfQuery = Struct.new(:query, :variables, keyword_init: true) do
       def initialize(query:, variables: nil)
-        @query = query
-        @variables = variables
-      end
-
-      def to_h
-        {
-          query: @query,
-          variables: @variables
-        }
+        super
       end
     end
 
-    class ResultOfQuery
-      attr_reader :result
-
-      def initialize(a)
-        @result = a
-      end
-    end
-
-    class ParamsOfFindLastShardBlock
-      attr_reader :address
-
-      def initialize(a)
-        @address = a
-      end
-
-      def to_h = { address: @address }
-    end
-
-    class ResultOfFindLastShardBlock
-      attr_reader :block_id
-
-      def initialize(a)
-        @block_id = a
-      end
-    end
-
-    class EndpointsSet
-      attr_reader :endpoints
-
-      def initialize(a)
-        @endpoints = a
-      end
-
-      def to_h = { endpoints: @endpoints }
-    end
+    ParamsOfFindLastShardBlock = Struct.new(:address)
+    ResultOfFindLastShardBlock = Struct.new(:block_id)
+    EndpointsSet = Struct.new(:endpoints)
 
     class ParamsOfQueryOperation
+      private_class_method :new
+
       attr_reader :type_, :params
 
-      def new_with_type_query_collection(params)
+      def self.new_with_type_query_collection(params)
         @type_ = :query_collection
         @params = params
       end
 
-      def new_with_type_wait_for_collection(params)
+      def self.new_with_type_wait_for_collection(params)
         @type_ = :wait_for_collection
         @params = params
       end
       
-      def new_with_type_aggregate_collection(params)
+      def self.new_with_type_aggregate_collection(params)
         @type_ = :aggregate_collection
         @params = params
       end
 
+      def self.new_with_type_query_counterparties(params)
+        @type_ = :query_counterparties
+        @params = params
+      end
+
       def to_h
         tp = {
           type: Helper.sym_to_capitalized_case_str(@type_)
@@ -212,41 +120,23 @@ module TonSdk
       end
     end
 
-    class ParamsOfBatchQuery
-      attr_reader :operations
-
-      def initialize(a)
-        @operations = a
-      end
-
-      def to_h = { operations: @operations.compact.map(&:to_h) }
-    end
-
-    class ResultOfBatchQuery
-      attr_reader :results
-
-      def initialize(a)
-        @results = a
+    ParamsOfBatchQuery = Struct.new(:operations) do
+      def to_h
+        {
+          operations: self.operations.compact.map(&:to_h)
+        }
       end
-
-      def to_h = { results: @results }
     end
 
-    class ParamsOfAggregateCollection
-      attr_reader :collection, :filter, :fields
-
+    ParamsOfAggregateCollection = Struct.new(:collection, :filter, :fields) do
       def initialize(collection:, filter: nil, fields: [])
-        @collection = collection
-        @filter = filter
-        @fields = fields
+        super
       end
 
       def to_h
-        {
-          collection: @collection,
-          filter: @filter,
-          fields: @fields.map(&:to_h)
-        }
+        h = super
+        h[:fields] = self.fields.map(&:to_h)
+        h
       end
     end
 
@@ -277,16 +167,69 @@ module TonSdk
       end
     end
 
-    class ResultOfAggregateCollection
-      attr_reader :values
+    ResultOfAggregateCollection = Struct.new(:values)
 
-      def initialize(a)
-        @values = a
+    ParamsOfQueryCounterparties = Struct.new(:account, :result, :first, :after, keyword_init: true) do
+      def initialize(account:, result:, first: nil, after: nil)
+        super
       end
+    end
 
-      def to_h = { values: @values }
+    ResultOfGetEndpoints = Struct.new(:query, :endpoints, keyword_init: true)
+
+    TransactionNode = Struct.new(
+      :id_,
+      :in_msg,
+      :out_msgs,
+      :account_addr,
+      :total_fees,
+      :aborted,
+      :exit_code,
+      keyword_init: true
+    ) do
+      def initialize(id_:, in_msg:, out_msgs:, account_addr:, total_fees:, aborted:, exit_code: nil)
+        super
+      end
     end
 
+    MessageNode = Struct.new(
+      :id_,
+      :src_transaction_id,
+      :dst_transaction_id,
+      :src,
+      :dst,
+      :value,
+      :bounce,
+      :decoded_body,
+      keyword_init: true
+    ) do
+      def initialize(
+        id_:,
+        src_transaction_id: nil,
+        dst_transaction_id: nil,
+        src: nil,
+        dst: nil,
+        value: nil,
+        bounce:,
+        decoded_body: nil
+      )
+        super
+      end
+    end
+
+    ParamsOfQueryTransactionTree = Struct.new(:in_msg, :abi_registry, :timeout, keyword_init: true) do
+      def initialize(in_msg:, abi_registry: [], timeout: nil)
+        super
+      end
+
+      def to_h
+        h = super
+        h[:abi_registry] = self.abi_registry&.map(&:to_h)
+        h
+      end
+    end
+
+    ResultOfQueryTransactionTree = Struct.new(:messages, :transactions, keyword_init: true)
 
 
     #
@@ -297,7 +240,7 @@ module TonSdk
       Interop::request_to_native_lib(
         ctx,
         "net.query_collection",
-        params.to_h.to_json,
+        params,
         is_single_thread_only: false
       ) do |resp|
         if resp.success?
@@ -314,7 +257,7 @@ module TonSdk
       Interop::request_to_native_lib(
         ctx,
         "net.wait_for_collection",
-        params.to_h.to_json,
+        params,
         is_single_thread_only: false
       ) do |resp|
         if resp.success?
@@ -328,7 +271,7 @@ module TonSdk
     end
 
     def self.unsubscribe(ctx, params)
-      Interop::request_to_native_lib(ctx, "net.unsubscribe", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "net.unsubscribe", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ""
@@ -343,7 +286,7 @@ module TonSdk
       Interop::request_to_native_lib(
         ctx,
         "net.subscribe_collection",
-        params.to_h.to_json,
+        params,
         client_callback: client_callback,
         is_single_thread_only: false
       ) do |resp|
@@ -358,7 +301,7 @@ module TonSdk
     end
 
     def self.query(ctx, params)
-      Interop::request_to_native_lib(ctx, "net.query", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "net.query", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfQuery.new(resp.result["result"])
@@ -370,7 +313,7 @@ module TonSdk
     end
 
     def self.suspend(ctx)
-      Interop::request_to_native_lib(ctx, "net.suspend", "") do |resp|
+      Interop::request_to_native_lib(ctx, "net.suspend") do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(result: "")
         else
@@ -380,7 +323,7 @@ module TonSdk
     end
 
     def self.resume(ctx)
-      Interop::request_to_native_lib(ctx, "net.resume", "") do |resp|
+      Interop::request_to_native_lib(ctx, "net.resume") do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(result: "")
         else
@@ -390,7 +333,7 @@ module TonSdk
     end
 
     def self.find_last_shard_block(ctx, params)
-      Interop::request_to_native_lib(ctx, "net.find_last_shard_block", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "net.find_last_shard_block", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: ResultOfFindLastShardBlock.new(resp.result["block_id"])
@@ -402,7 +345,7 @@ module TonSdk
     end
 
     def self.fetch_endpoints(ctx)
-      Interop::request_to_native_lib(ctx, "net.fetch_endpoints", nil) do |resp|
+      Interop::request_to_native_lib(ctx, "net.fetch_endpoints") do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: EndpointsSet.new(resp.result["endpoints"])
@@ -414,7 +357,7 @@ module TonSdk
     end
 
     def self.set_endpoints(ctx, params)
-      Interop::request_to_native_lib(ctx, "net.set_endpoints", params.to_h.to_json) do |resp|
+      Interop::request_to_native_lib(ctx, "net.set_endpoints", params) do |resp|
         if resp.success?
           yield NativeLibResponsetResult.new(
             result: nil
@@ -427,7 +370,7 @@ module TonSdk
   end
 
   def self.batch_query(ctx, params)
-    Interop::request_to_native_lib(ctx, "net.batch_query", params.to_h.to_json) do |resp|
+    Interop::request_to_native_lib(ctx, "net.batch_query", params) do |resp|
       if resp.success?
         yield NativeLibResponsetResult.new(
           result: ResultOfBatchQuery.new(resp.result["results"])
@@ -439,7 +382,7 @@ module TonSdk
   end
 
   def self.aggregate_collection(ctx, params)
-    Interop::request_to_native_lib(ctx, "net.aggregate_collection", params.to_h.to_json) do |resp|
+    Interop::request_to_native_lib(ctx, "net.aggregate_collection", params) do |resp|
       if resp.success?
         yield NativeLibResponsetResult.new(
           result: ResultOfAggregateCollection.new(resp.result["values"])
@@ -449,4 +392,46 @@ module TonSdk
       end
     end
   end
+
+  def self.get_endpoints(ctx, params)
+    Interop::request_to_native_lib(ctx, "net.get_endpoints", params) do |resp|
+      if resp.success?
+        yield NativeLibResponsetResult.new(
+          result: ResultOfGetEndpoints.new(
+            query: resp.result["query"],
+            endpoints: resp.result["endpoints"],
+          )
+        )
+      else
+        yield resp
+      end
+    end
+  end
+
+  def self.query_counterparties(ctx, params)
+    Interop::request_to_native_lib(ctx, "net.query_counterparties", params) do |resp|
+      if resp.success?
+        yield NativeLibResponsetResult.new(
+          result: ResultOfQueryCollection.new(resp.result["result"])
+        )
+      else
+        yield resp
+      end
+    end
+  end
+
+  def self.query_transaction_tree(ctx, params)
+    Interop::request_to_native_lib(ctx, "net.query_transaction_tree", params) do |resp|
+      if resp.success?
+        yield NativeLibResponsetResult.new(
+          result: ResultOfQueryTransactionTree.new(
+            messages: resp.result["messages"],
+            transactions: resp.result["transactions"],
+          )
+        )
+      else
+        yield resp
+      end
+    end
+  end
 end