ever_sdk_client 1.36.0

data/lib/ever_sdk_client/debot.rb

@@ -0,0 +1,367 @@
+module EverSdk
+  module Debot
+
+    #
+    # types
+    #
+
+    module ErrorCode
+      START_FAILED = 801
+      FETCH_FAILED = 802
+      EXECUTION_FAILED = 803
+      INVALID_HANDLE = 804
+      INVALID_JSON_PARAMS = 805
+      INVALID_FUNCTION_ID = 806
+      INVALID_ABI = 807
+      GET_METHOD_FAILED = 808
+      INVALID_MSG = 809
+      EXTERNAL_CALL_FAILED = 810
+      BROWSER_CALLBACK_FAILED = 811
+      OPERATION_REJECTED = 812
+      DEBOT_NO_CODE = 813
+    end
+
+    DebotAction = KwStruct.new(:description, :name, :action_type, :to, :attributes, :misc) do
+      def to_h
+        {
+          description: description,
+          name: name,
+          action_type: action_type,
+          to: to,
+          attributes: attributes,
+          misc: misc
+        }
+      end
+
+      def self.from_json(j)
+        return if j.nil?
+
+        self.new(
+          description: j["description"],
+          name: j["name"],
+          action_type: j["action_type"],
+          to: j["to"],
+          attributes: j["attributes"],
+          misc: j["misc"]
+        )
+      end
+    end
+
+    DebotInfo = KwStruct.new(
+      :name,
+      :version,
+      :publisher,
+      :caption,
+      :author,
+      :support,
+      :hello,
+      :language,
+      :dabi,
+      :icon,
+      :interfaces,
+      :dabi_version
+    ) do
+      def initialize(
+        name: nil,
+        version: nil,
+        publisher: nil,
+        caption: nil,
+        author: nil,
+        support: nil,
+        hello: nil,
+        language: nil,
+        dabi: nil,
+        icon: nil,
+        interfaces: [],
+        dabi_version: nil
+      )
+        super
+      end
+    end
+
+    class DebotActivity
+      attr_reader :type, :msg, :dst, :out, :fee, :setcode, :signkey, :signing_box_handle
+    end
+
+    Spending = KwStruct.new(:amount, :dst)
+
+    ParamsOfInit = KwStruct.new(:address)
+
+    RegisteredDebot = KwStruct.new(:debot_handle, :debot_abi, :info) do
+      def to_h
+        {
+          debot_handle: debot_handle,
+          debot_abi: debot_abi,
+          info: info.to_h
+        }
+      end
+    end
+
+    class ParamsOfAppDebotBrowser
+      private_class_method :new
+
+      TYPE_VALUES = [
+        :log,
+        :switch,
+        :switch_completed,
+        :show_action,
+        :input,
+        :get_signing_box,
+        :invoke_debot,
+        :send,
+        :approve
+      ]
+
+      attr_reader :type, :msg, :context_id, :action, :prompt, :debot_addr, :message, :activity
+
+      def self.new_with_type_log(msg)
+        @type = :log
+        @msg = msg
+      end
+
+      def self.new_with_type_switch(context_id)
+        @type = :switch
+        @context_id = context_id
+      end
+
+      def self.new_with_type_switch_completed
+        @type = :switch_completed
+      end
+
+      def self.new_with_type_show_action(action)
+        @type = :show_action
+        @action = action
+      end
+
+      def self.new_with_type_input(prompt)
+        @type = :input
+        @prompt = prompt
+      end
+
+      def self.new_with_type_get_signing_box
+        @type = :get_signing_box
+      end
+
+      def self.new_with_type_invoke_debot(debot_addr, action)
+        @type = :invoke_debot
+        @debot_addr = debot_addr
+        @action = action
+      end
+
+      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),
+          msg: msg,
+          context_id: context_id,
+          action: action,
+          prompt: prompt,
+          debot_addr: debot_addr,
+          message: message
+        }
+      end
+
+      def self.from_json(j)
+        return nil if j.nil?
+
+        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
+
+      def self.parse_type(type_str)
+        parsed_type = Helper.capitalized_case_str_to_snake_case_sym(type_str)
+
+        unless TYPE_VALUES.include?(type_str)
+          raise ArgumentError.new("type #{type_str} is unknown; known types: #{TYPE_VALUES}")
+        end
+
+        parsed_type
+      end
+    end
+
+    class ResultOfAppDebotBrowser
+      private_class_method :new
+
+      attr_reader :type, :value, :signing_box, :is_approved
+
+      def self.new_with_type_input(a)
+        @type = :input
+        @value = a
+      end
+
+      def self.new_with_type_get_signing_box(a)
+        @type = :get_signing_box
+        @signing_box = signing_box
+      end
+
+      def self.new_with_type_invoke_debot
+        @type = :invoke_debot
+      end
+
+      def self.new_with_type_approve(a)
+        @type = :approve
+        @is_approved = a
+      end
+    end
+
+    ParamsOfStart = KwStruct.new(:debot_handle)
+
+    ParamsOfFetch = KwStruct.new(:address)
+
+    ResultOfFetch = KwStruct.new(:info)
+
+    ParamsOfExecute = KwStruct.new(:debot_handle, :action) do
+      def to_h
+        {
+          debot_handle: debot_handle,
+          action: action.to_h
+        }
+      end
+    end
+
+    ParamsOfSend = KwStruct.new(:debot_handle, :message)
+
+    ParamsOfRemove = KwStruct.new(:debot_handle)
+
+    #
+    # functions
+    #
+
+    def self.init(ctx, params, app_browser_obj = nil)
+      Interop::request_to_native_lib(
+        ctx,
+        "debot.init",
+        params
+      ) do |resp|
+        if resp.success?
+          debot_info = resp.result["info"].transform_keys(&:to_sym)
+          debot_info[:dabi_version] = debot_info.delete(:dabiVersion)
+          yield NativeLibResponseResult.new(
+            result: RegisteredDebot.new(
+              debot_handle: resp.result["debot_handle"],
+              debot_abi: resp.result["debot_abi"],
+              info: DebotInfo.new(**debot_info)
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.start(ctx, params)
+      Interop::request_to_native_lib(
+        ctx,
+        "debot.start",
+        params,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: nil
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.fetch(ctx, params)
+      Interop::request_to_native_lib(
+        ctx,
+        "debot.fetch",
+        params,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          debot_info = resp.result["info"].transform_keys(&:to_sym)
+          debot_info[:dabi_version] = debot_info.delete(:dabiVersion)
+          yield NativeLibResponseResult.new(
+            result: ResultOfFetch.new(
+              info: DebotInfo.new(**debot_info)
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.execute(ctx, params)
+      Interop::request_to_native_lib(ctx, "debot.execute", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: nil
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.remove(ctx, params)
+      Interop::request_to_native_lib(ctx, "debot.remove", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: nil
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.send(ctx, params)
+      Interop::request_to_native_lib(ctx, "debot.send", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: nil
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end

data/lib/ever_sdk_client/helper.rb

@@ -0,0 +1,20 @@
+module EverSdk
+  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/ever_sdk_client/interop.rb

@@ -0,0 +1,230 @@
+require 'ffi'
+require 'rbconfig'
+require 'concurrent'
+require 'logger'
+
+module EverSdk
+  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 = nil,
+      client_callback: nil,
+      is_single_thread_only: true
+    )
+      function_name_tc_str = TcStringData.from_string(function_name)
+      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)
+      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 achieved 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 NativeLibResponseResult.new(result: tc_data_json_content)
+            end
+  
+          when TcResponseCodes::ERROR
+            if block_given?
+              yield NativeLibResponseResult.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/ever_sdk_client/kw_struct.rb

@@ -0,0 +1,7 @@
+module EverSdk
+  class KwStruct < Struct
+    def self.new(*several_variants, keyword_init: true)
+      super
+    end
+  end
+end