ton_sdk_client 1.7.1

data/lib/ton_sdk_client/helper.rb

@@ -0,0 +1,20 @@
+module TonSdk
+  class Helper
+
+    # converts a symbol which may contain _, into a capital-case string
+    # :aaa_bbb_ccc -> AaaBbbCcc
+    def self.sym_to_capitalized_case_str(symb)
+      symb.to_s.split('_').map(&:capitalize).join
+    end
+
+
+    # converts a capital-case string
+    # into a symbol
+    # AaaBbbCcc --> :aaa_bbb_ccc
+    def self.capitalized_case_str_to_snake_case_sym(str)
+      str.split(/(?=[A-Z])/).map(&:downcase).join("_").to_sym
+    end
+
+    def self.base64_from_hex(hex_digest) = [[hex_digest].pack("H*")].pack("m0")
+  end
+end

data/lib/ton_sdk_client/interop.rb

@@ -0,0 +1,230 @@
+require 'ffi'
+require 'rbconfig'
+require 'concurrent'
+require 'logger'
+
+module TonSdk
+  module Interop
+    extend FFI::Library
+
+    class << self
+      attr_reader :logger
+    end
+
+    @logger = Logger.new(STDOUT)
+
+    class TcStringData < FFI::Struct
+      layout :content, :pointer,
+        :len, :uint32
+
+      def self.from_string(s)
+        tcs = TcStringData.new
+        bytes_count = s.unpack("C*").size
+        ptr1 = FFI::MemoryPointer.new(:char, bytes_count)
+        ptr1.put_bytes(0, s, 0, bytes_count)
+        tcs[:content] = ptr1
+        tcs[:len] = ptr1.size
+        tcs
+      end
+    end
+
+    class TcResponse < FFI::Struct
+      layout :result_json, TcStringData,
+        :error_json, TcStringData
+    end
+
+    DEFAULT_LIB_NAME = 'tonclient'
+    base_lib_name2 = case RbConfig::CONFIG['host_os']
+    when /linux/
+      'linux'
+    when /darwin/
+      'darwin'
+    when /mswin|mingw32|windows/
+      'win32'
+    else
+      raise "unsupported OS: #{RbConfig::CONFIG['host_os']}"
+    end
+
+    lib_full_name = if !ENV['TON_CLIENT_NATIVE_LIB_NAME'].nil?
+      ENV['TON_CLIENT_NATIVE_LIB_NAME']
+    else
+      fl_nm = "#{DEFAULT_LIB_NAME}.#{FFI::Platform::LIBSUFFIX}"
+      File.join(File.expand_path(File.dirname(File.dirname(__dir__))), fl_nm)
+    end
+
+    ffi_lib(lib_full_name)
+
+
+
+
+    #
+    # in C
+    #
+    # enum tc_response_types_t {
+    #   tc_response_success = 0,
+    #   tc_response_error = 1,
+    #   tc_response_nop = 2,
+    #   tc_response_custom = 100,
+    # };
+    module TcResponseCodes
+      SUCCESS = 0
+      ERROR = 1
+      NOP = 2
+      APP_REQUEST = 3
+      APP_NOTIFY = 4
+      CUSTOM = 100
+      MAX = 999
+    end
+
+
+    #
+    # in C
+    #
+    # tc_string_handle_t* tc_create_context(tc_string_data_t config);
+    # void tc_destroy_context(uint32_t context);
+
+    attach_function(:tc_create_context, [TcStringData.by_value], :pointer)
+    attach_function(:tc_destroy_context, [:uint32], :void)
+
+
+    #
+    # in C
+    #
+    # tc_string_data_t tc_read_string(const tc_string_handle_t* string);
+    # void tc_destroy_string(const tc_string_handle_t* string);
+
+    attach_function(:tc_read_string, [:pointer], TcStringData.by_value)
+    attach_function(:tc_destroy_string, [:pointer], :void)
+
+
+    #
+    # in C
+    #
+    # void tc_request(
+    #   uint32_t context,
+    #   tc_string_data_t function_name,
+    #   tc_string_data_t function_params_json,
+    #   uint32_t request_id,
+    #   tc_response_handler_t response_handler);
+
+    # typedef void (*tc_response_handler_t)(
+    #   uint32_t request_id,
+    #   tc_string_data_t params_json,
+    #   uint32_t response_type,
+    #   bool finished);
+
+    callback(:tc_response_handler, [:uint32, TcStringData.by_value, :uint32, :bool], :void)
+    attach_function(:tc_request, [:uint32, TcStringData.by_value, TcStringData.by_value, :uint32, :tc_response_handler], :void) # TODO possibly blocking: true
+
+    #
+    # in C
+    #
+    # tc_string_handle_t* tc_request_sync(
+    #   uint32_t context,
+    #   tc_string_data_t function_name,
+    #   tc_string_data_t function_params_json);
+    attach_function(:tc_request_sync, [:uint32, TcStringData.by_value, TcStringData.by_value], :pointer)
+
+
+
+    @@request_counter = Concurrent::AtomicFixnum.new(1)
+
+    def self.request_to_native_lib(
+      ctx,
+      function_name,
+      function_params_json = nil,
+      client_callback: nil,
+      is_single_thread_only: trfue
+    )
+      function_name_tc_str = TcStringData.from_string(function_name)
+      function_params_json_str = function_params_json || ""
+      function_params_json_tc_str = TcStringData.from_string(function_params_json_str)
+
+      @sm = Concurrent::Semaphore.new(1)
+      if is_single_thread_only == true
+        @sm.acquire()
+      end
+
+
+      # using @@request_counter here to pass a @@request_counter and handlers and then retrieve them
+      # is probably isn't needed.
+      # Thanks to the way Ruby is, the same affect can be achived by a block which is an easier way.
+      # Nonetheless, @@request_counter is incremented with each request and then sent out to a server
+      # in order to keep a server happy,
+      # because otherwise a server will, probably, reply in a wrong way.
+
+      self.tc_request(
+        ctx,
+        function_name_tc_str,
+        function_params_json_tc_str,
+        @@request_counter.value
+      ) do |req_id, params_json, response_type, is_finished|
+
+        tc_data_json_content = if params_json[:len] > 0
+          res = params_json[:content].read_string(params_json[:len])
+          JSON.parse(res)
+        else
+          ''
+        end
+
+        begin
+          case response_type
+
+          when TcResponseCodes::SUCCESS
+            if block_given?
+              yield NativeLibResponsetResult.new(result: tc_data_json_content)
+            end
+  
+          when TcResponseCodes::ERROR
+            if block_given?
+              yield NativeLibResponsetResult.new(error: tc_data_json_content)
+            end
+
+          when TcResponseCodes::NOP
+            nil
+
+          when TcResponseCodes::APP_REQUEST
+            if !client_callback.nil?
+              client_callback.call(:request, tc_data_json_content)
+            end
+
+          when TcResponseCodes::APP_NOTIFY
+            if !client_callback.nil?
+              client_callback.call(:notify, tc_data_json_content)
+            end
+
+          when TcResponseCodes::CUSTOM..TcResponseCodes::MAX
+            if !client_callback.nil?
+              client_callback.call(:custom, tc_data_json_content)
+            end
+
+          else
+            raise ArgumentError.new("unsupported response type: #{response_type}")
+          end
+
+        rescue => e
+          @logger.error(e)
+        ensure
+          if is_single_thread_only == true
+            @sm.release()
+          end
+        end
+      end
+
+
+
+      if is_single_thread_only == true
+        @sm.acquire()
+      end
+
+      @@request_counter.increment()
+      nil
+    end
+
+    def self.request_to_native_lib_sync(ctx, function_name, function_params_json)
+      function_name_tc_str = TcStringData.from_string(function_name)
+      function_params_json_tc_str = TcStringData.from_string(function_params_json)
+      self.tc_request_sync(ctx, function_name_tc_str, function_params_json_tc_str)
+    end
+  end
+end

data/lib/ton_sdk_client/net.rb

@@ -0,0 +1,452 @@
+module TonSdk
+  module Net
+
+    #
+    # types
+    #
+
+    module ErrorCode
+      QUERY_FAILED = 601
+      SUBSCRIBE_FAILED = 602
+      WAIT_FOR_FAILED = 603
+      GET_SUBSCRIPTION_FAILED = 604
+      INVALID_SERVER_RESPONSE = 605
+      CLOCK_OUT_OF_SYNC = 606
+      WAIT_FOR_TIMEOUT = 607
+      GRAPHQL_ERROR = 608
+      NETWORK_MODULE_SUSPENDED = 609
+      WEBSOCKET_DISCONNECTED = 610
+      NOT_SUPPORTED = 611
+      NO_ENDPOINTS_PROVIDED = 612
+      GRAPHQL_WEBSOCKET_INIT_ERROR = 613,
+      NETWORK_MODULE_RESUMED = 614
+    end
+
+    class OrderBy
+      SORT_DIRECTION_VALUES = [:asc, :desc]
+
+      attr_reader :path, :direction
+
+      def initialize(path:, direction:)
+        @path = path
+        unless SORT_DIRECTION_VALUES.include?(direction)
+          raise ArgumentError.new("direction #{direction} doesn't exist; existing values: #{SORT_DIRECTION_VALUES}")
+        end
+
+        @direction = direction
+      end
+    end
+
+    class ParamsOfQueryCollection
+      attr_reader :collection, :filter, :result, :order, :limit
+
+      def initialize(collection: , filter: nil, result: , order: [], limit: nil)
+        @collection = collection
+        @filter = filter
+        @result = result
+        @order = order
+        @limit = limit
+      end
+
+      def to_h
+        ord_h_s = if !@order.nil?
+          @order.map do |x|
+            {
+              path: x.path,
+              direction: x.direction.to_s.upcase
+            }
+          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
+      end
+    end
+
+    class ParamsOfWaitForCollection
+      attr_reader :collection, :filter, :result, :timeout
+
+      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
+        }
+      end
+    end
+
+    class ResultOfWaitForCollection
+      attr_reader :result
+
+      def initialize(a)
+        @result = a
+      end
+    end
+
+    class ParamsOfSubscribeCollection
+      attr_reader :collection, :filter, :result
+
+      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
+      end
+
+      def to_h = { handle: @handle }
+    end
+
+    class ParamsOfQuery
+      attr_reader :query, :variables
+
+      def initialize(query:, variables: nil)
+        @query = query
+        @variables = variables
+      end
+
+      def to_h
+        {
+          query: @query,
+          variables: @variables
+        }
+      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
+
+    class ParamsOfQueryOperation
+      attr_reader :type_, :params
+
+      def new_with_type_query_collection(params)
+        @type_ = :query_collection
+        @params = params
+      end
+
+      def new_with_type_wait_for_collection(params)
+        @type_ = :wait_for_collection
+        @params = params
+      end
+      
+      def new_with_type_aggregate_collection(params)
+        @type_ = :aggregate_collection
+        @params = params
+      end
+
+      def to_h
+        tp = {
+          type: Helper.sym_to_capitalized_case_str(@type_)
+        }
+
+        param_keys = @params.to_h
+        tp.merge(param_keys)
+      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
+      end
+
+      def to_h = { results: @results }
+    end
+
+    class ParamsOfAggregateCollection
+      attr_reader :collection, :filter, :fields
+
+      def initialize(collection:, filter: nil, fields: [])
+        @collection = collection
+        @filter = filter
+        @fields = fields
+      end
+
+      def to_h
+        {
+          collection: @collection,
+          filter: @filter,
+          fields: @fields.map(&:to_h)
+        }
+      end
+    end
+
+    class FieldAggregation
+      AGGREGATION_FN_VALUES = [
+        :count,
+        :min,
+        :max,
+        :sum,
+        :average
+      ]
+
+      attr_reader :field, :fn
+
+      def initialize(field:, fn:)
+        unless AGGREGATION_FN_VALUES.include?(fn)
+          raise ArgumentError.new("aggregate function #{fn} doesn't exist; existing values: #{AGGREGATION_FN_VALUES}")
+        end
+        @field = field
+        @fn = fn
+      end
+
+      def to_h
+        {
+          field: @field,
+          fn: @fn.to_s.upcase
+        }
+      end
+    end
+
+    class ResultOfAggregateCollection
+      attr_reader :values
+
+      def initialize(a)
+        @values = a
+      end
+
+      def to_h = { values: @values }
+    end
+
+
+
+    #
+    # functions
+    #
+
+    def self.query_collection(ctx, params)
+      Interop::request_to_native_lib(
+        ctx,
+        "net.query_collection",
+        params.to_h.to_json,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfQueryCollection.new(resp.result["result"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.wait_for_collection(ctx, params)
+      Interop::request_to_native_lib(
+        ctx,
+        "net.wait_for_collection",
+        params.to_h.to_json,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfWaitForCollection.new(resp.result["result"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.unsubscribe(ctx, params)
+      Interop::request_to_native_lib(ctx, "net.unsubscribe", params.to_h.to_json) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ""
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.subscribe_collection(ctx, params, client_callback: nil)
+      Interop::request_to_native_lib(
+        ctx,
+        "net.subscribe_collection",
+        params.to_h.to_json,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfSubscribeCollection.new(resp.result["handle"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.query(ctx, params)
+      Interop::request_to_native_lib(ctx, "net.query", params.to_h.to_json) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfQuery.new(resp.result["result"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.suspend(ctx)
+      Interop::request_to_native_lib(ctx, "net.suspend", "") do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(result: "")
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.resume(ctx)
+      Interop::request_to_native_lib(ctx, "net.resume", "") do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(result: "")
+        else
+          yield resp
+        end
+      end
+    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|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfFindLastShardBlock.new(resp.result["block_id"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.fetch_endpoints(ctx)
+      Interop::request_to_native_lib(ctx, "net.fetch_endpoints", nil) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: EndpointsSet.new(resp.result["endpoints"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.set_endpoints(ctx, params)
+      Interop::request_to_native_lib(ctx, "net.set_endpoints", params.to_h.to_json) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: nil
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+
+  def self.batch_query(ctx, params)
+    Interop::request_to_native_lib(ctx, "net.batch_query", params.to_h.to_json) do |resp|
+      if resp.success?
+        yield NativeLibResponsetResult.new(
+          result: ResultOfBatchQuery.new(resp.result["results"])
+        )
+      else
+        yield resp
+      end
+    end
+  end
+
+  def self.aggregate_collection(ctx, params)
+    Interop::request_to_native_lib(ctx, "net.aggregate_collection", params.to_h.to_json) do |resp|
+      if resp.success?
+        yield NativeLibResponsetResult.new(
+          result: ResultOfAggregateCollection.new(resp.result["values"])
+        )
+      else
+        yield resp
+      end
+    end
+  end
+end