everscale-client-ruby 1.1.23

data/lib/code_generator/code_generator.rb

@@ -0,0 +1,339 @@
+require 'byebug'
+require 'json'
+require File.dirname(__FILE__) + '/helpers.rb'
+
+class CodeGenerator
+  include InstanceHelpers
+
+  attr_accessor :types
+  attr_accessor :root_dir
+
+  TAB = "  "
+
+  def initialize(types, root_dir)
+    @types = types
+    @root_dir = root_dir
+  end
+
+  def generate_self_code
+    generateModules(types)
+    generateReadme(types)
+  end
+
+  private
+
+  def generateModules(types)
+    types.modules.each do |mod|
+      modulesFolder = root_dir + "/lib/everscale-client-ruby/Client"
+      moduleFilePath = "#{modulesFolder}/#{mod.name.capitalize}.rb"
+      newModuleContent = ""
+      if mod.name == "client"
+          newModuleContent = generateClientModule(mod, types.modules)
+      else
+          newModuleContent = generateModule(mod)
+      end
+      if File.exists?(moduleFilePath)
+          File.delete(moduleFilePath)
+      end
+      File.open(moduleFilePath, 'w+') { |f| f.write(newModuleContent) }
+    end
+    
+    p 'generate_self_code ok'
+  end
+
+  def generateReadme(types)
+    readmePath = root_dir + "/README.md"
+    content = %{
+# Ruby Client for Free TON SDK
+
+[![GEM](https://img.shields.io/badge/ruby-gem-orange)](https://rubygems.org/gems/everscale-client-ruby)
+[![SPM](https://img.shields.io/badge/SDK%20VERSION-#{types.version}-green)](https://github.com/tonlabs/TON-SDK)
+
+## Install
+
+Install gem
+```bash
+gem install ton-client-ruby
+```
+
+Install TON-SDK
+```bash
+ton-client-ruby setup
+# result - path to dylib file for ton-client-ruby configuration
+```
+
+### Manual build FreeTON SDK
+0. Install Rust to your OS
+1. git clone https://github.com/tonlabs/TON-SDK
+2. cd ./TON-SDK
+3. cargo update
+4. cargo build --release
+
+## Usage
+
+```ruby
+# For MAcOS
+TonClient.configure { |config| config.ffi_lib(./TON-SDK/target/release/libton_client.dylib) }
+# For Linux
+# TonClient.configure { |config| config.ffi_lib(./TON-SDK/target/release/libton_client.so) }
+
+client = TonClient.create(config: {network: {server_address: "net.ton.dev"}})
+
+# All methods are asynchronous
+
+# example: call method for Crypto module
+payload = {composite: '17ED48941A08F981'}
+client.crypto.factorize(payload) do |response|
+  p response.result['factors']
+end
+
+# e.g. ...
+```\n\n
+}
+    content << "## All Modules, methods and types\n\n"
+
+    # types
+    content << "<details>\n#{TAB}<summary>Types</summary>\n\n"
+    
+    content << "#{customTypes()}\n"
+
+    types.modules.each do |mod|
+      (mod.enums || []).each do |type|
+        content << checkComment(type.summary, 0) if type.summary
+        content << checkComment(type.description, 0) if type.description
+        content << "\n- #### #{type.name}\n"
+        (type.cases || []).each do |enum_case|
+          content << "#{checkComment(enum_case.summary, 1).gsub(/#/, '')}" if enum_case.summary
+          content << "#{checkComment(enum_case.description, 1).gsub(/#/, '')}" if enum_case.description
+          content << "#{TAB}- case #{enum_case.name} = #{enum_case.value}\n\n"
+        end
+      end
+
+      (mod.types || []).each do |type|
+        content << checkComment(type.summary, 0) if type.summary
+        content << checkComment(type.description, 0) if type.description
+        content << "\n- #### #{type.name}\n"
+        (type.fields || []).each do |field|
+          content << "#{checkComment(field.summary, 1).gsub(/#/, '')}\n" if field.summary
+          content << "#{checkComment(field.description, 1).gsub(/#/, '')}\n" if field.description
+          content << "#{TAB}- #{field.name}: #{field.type}\n\n"
+        end
+      end
+    end
+    content << "</details>\n\n"
+
+    # methods
+    types.modules.each do |mod|
+      content << "<details>\n#{TAB}<summary>#{mod.name&.upcase}</summary>\n\n"
+      (mod.functions || []).each do |function|
+        content << "```ruby\n"
+        content << checkComment(function.summary, 2) if function.summary
+        content << checkComment(function.description, 2) if function.description
+        content << "\n#{TAB}#{TAB}def #{function.name}"
+        if function.arguments.empty?
+          content << "(&block)\n"
+        else
+          content << "(payload, &block)\n"
+        end
+        content << getFunctionComment(function, types)
+        content << "```\n"
+      end
+      content << "</details>\n\n"
+    end
+
+    content << %{
+\n## Tests
+
+1. create __.env.test__ file inside root directory of this library with variables   
+
+example for NodeSE   
+```
+spec_ffi=./TON-SDK/target/release/libton_client.dylib
+server_address=http://localhost:80
+giver_abi_name=GiverNodeSE
+giver_amount=10000000000
+```
+2. Run tests: inside folder of this library execute this commands      
+**rspec spec/binding.rb**   
+**rspec spec/client.rb**  
+**rspec spec/context.rb**  
+**rspec spec/abi.rb**   
+**rspec spec/boc.rb**   
+**rspec spec/crypto.rb**   
+**rspec spec/net.rb**   
+**rspec spec/processing.rb**   
+**rspec spec/tvm.rb**   
+**rspec spec/utils.rb**
+
+\n## Update\n\n
+```\n
+ton-client-ruby update\n 
+```\n\n
+or\n\n 
+```\n
+curl https://raw.githubusercontent.com/tonlabs/TON-SDK/master/tools/api.json > api.json\n\n
+```\n\n
+```\n
+ton-client-ruby update ./api.json\n
+```\n
+or\n\n 
+```\n
+cd ton-client-ruby\n
+```\n\n
+```\n
+./bin/ton-client-ruby update\n
+```\n 
+}
+    content = checkContent(content)    
+    if File.exists?(readmePath)
+        File.delete(readmePath)
+    end
+    File.open(readmePath, 'w+') { |f| f.write(content) }
+  end
+
+  private def checkContent(content)
+    content.gsub!(/^([\s]+)# RESPONSE/, "\n\\1# RESPONSE")
+    content.gsub(/<Optional>/i, '&lt;Optional&gt;')
+  end
+
+  def customTypes
+    content = %{
+- #### #{lib_prefix}MnemonicDictionary
+#{TAB}- case TON = 0
+#{TAB}- case ENGLISH = 1
+#{TAB}- case CHINESE_SIMPLIFIED = 2
+#{TAB}- case CHINESE_TRADITIONAL = 3
+#{TAB}- case FRENCH = 4
+#{TAB}- case ITALIAN = 5
+#{TAB}- case JAPANESE = 6
+#{TAB}- case KOREAN = 7
+#{TAB}- case SPANISH = 8
+}
+  content
+  end
+
+  private def checkComment(string, tabs = 1)
+      replacedString = "\n"
+      tab = ""
+      tabs.times do |i|
+          tab << TAB
+      end
+      comment = "#"
+      replacedString << "#{tab}#{comment} "
+      symbolsWithSpace = "\\.|\\:|\\!|\\?|\\;"
+      regxp = /([^#{symbolsWithSpace}])\n/
+      result = string
+      result.gsub!(/\n+/, "\n")
+      result.gsub!(/ \n/, "\n#{comment} ")
+      result.gsub!(/(#{symbolsWithSpace})\s*\n/, "\\1#{replacedString}")
+      result.gsub!(regxp, "\\1")
+      "#{tab}# #{result}"
+  end
+
+  private def generateClientModule(mod, modules)
+    content = "module TonClient\n\n#{TAB}class #{mod.name.capitalize}\n#{TAB}#{TAB}include CommonInstanceHelpers\n\n"
+    content << "#{TAB}#{TAB}attr_reader :core, :context\n"
+    content << "#{TAB}#{TAB}private_accessor "
+    modules.each_with_index do |m, i|
+      next if m.name.downcase == 'client'
+      content << ((modules.size - 1) == i ? ":_#{m.name}\n" : ":_#{m.name}, ")
+    end
+    content << "#{TAB}#{TAB}MODULE = self.to_s.downcase.gsub(/^(.+::|)(\\w+)$/, '\\2').freeze\n\n"
+    content << "#{TAB}#{TAB}def initialize(context: Context.new, core: TonClient::TonBinding)\n"
+    content << "#{TAB}#{TAB}#{TAB}@context = context\n"
+    content << "#{TAB}#{TAB}#{TAB}@core = core\n#{TAB}#{TAB}end\n\n"
+    content << "#{TAB}#{TAB}def destroy_context\n"
+    content << "#{TAB}#{TAB}#{TAB}core.tc_destroy_context(context.id)\n#{TAB}#{TAB}end\n\n"
+    modules.each_with_index do |m, i|
+      next if m.name.downcase == 'client'
+      content << "#{TAB}#{TAB}def #{m.name}\n"
+      content << "#{TAB}#{TAB}#{TAB}_#{m.name} ||= #{m.name.capitalize}.new(context: context)\n"
+      content << "#{TAB}#{TAB}end\n\n"
+    end
+
+    mod.functions.each do |func|
+      content << gen_function(func, types)
+    end
+
+    content << "#{TAB}end\n"
+    content << "end\n\n"
+
+    content
+  end
+
+  private def generateModule(mod)
+    content = "module TonClient\n\n#{TAB}class #{mod.name.capitalize}\n#{TAB}#{TAB}include CommonInstanceHelpers\n\n"
+    content << "#{TAB}#{TAB}attr_reader :core, :context\n"
+    content << "#{TAB}#{TAB}MODULE = self.to_s.downcase.gsub(/^(.+::|)(\\w+)$/, '\\2').freeze\n\n"
+    content << "#{TAB}#{TAB}def initialize(context: Context.new, core: TonClient::TonBinding)\n"
+    content << "#{TAB}#{TAB}#{TAB}@context = context\n"
+    content << "#{TAB}#{TAB}#{TAB}@core = core\n"
+    content << "#{TAB}#{TAB}end\n\n"
+
+    mod.functions.each do |func|
+      content << gen_function(func, types)
+    end
+
+    content << "#{TAB}end\n"
+    content << "end\n\n"
+
+    content
+  end
+
+  private def gen_function(function, types)
+    content = getFunctionComment(function, types)
+    content << "#{TAB}#{TAB}def #{function.name}"
+    if function.arguments.empty?
+      content << "(&block)\n"
+      content << "#{TAB}#{TAB}#{TAB}core.requestLibrary(context: context.id, method_name: full_method_name(MODULE, __method__.to_s), payload: {}, &block)\n"
+    else
+      content << "(payload, &block)\n"
+      content << "#{TAB}#{TAB}#{TAB}core.requestLibrary(context: context.id, method_name: full_method_name(MODULE, __method__.to_s), payload: payload, &block)\n"
+    end
+    content << "#{TAB}#{TAB}end\n\n"
+
+    content
+  end
+
+  def getFunctionComment(function, types)
+    content = ''
+    if argument = function.arguments.first
+      content << "#{TAB}#{TAB}# INPUT: #{argument.type}\n"
+      if types.all_types[argument.type].respond_to?(:fields)
+        types.all_types[argument.type].fields.each do |arg|
+          content << "#{TAB}#{TAB}# #{arg.name}: #{arg.type} - "
+          content << "#{TAB}#{TAB}# #{checkComment(arg.summary, 2)}" if arg.summary
+          content << "#{TAB}#{TAB}# #{checkComment(arg.description, 2)}" if arg.description
+          content << "\n"
+        end
+      elsif types.all_types[argument.type].respond_to?(:cases)
+      end
+    end
+    
+    if types.all_types[function.result]
+      content << "#{TAB}#{TAB}# RESPONSE: #{function.result}\n"
+      if types.all_types[function.result].respond_to?(:fields)
+        types.all_types[function.result].fields.each do |arg|
+          content << "#{TAB}#{TAB}# #{arg.name}: #{arg.type} - "
+          content << "#{TAB}#{TAB}# #{checkComment(arg.summary, 2)}" if arg.summary
+          content << "#{TAB}#{TAB}# #{checkComment(arg.description, 2)}" if arg.description
+          content << "\n"
+        end
+      elsif types.all_types[function.result].respond_to?(:cases)
+      end
+    end
+
+    content
+  end
+end
+
+
+
+
+
+
+
+
+
+
+

data/lib/code_generator/helpers.rb

@@ -0,0 +1,13 @@
+require 'json'
+require 'byebug'
+
+module InstanceHelpers
+  
+  def lib_prefix 
+    '' 
+  end
+
+  def lib_enum_postfix
+    ''
+  end
+end

data/lib/code_generator/release.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+script_file_path = File.expand_path(File.dirname(__FILE__))
+
+require "#{script_file_path}/api_converter.rb"
+require "#{script_file_path}/code_generator.rb"
+GEM_DIR = "#{script_file_path}/../.."
+
+
+`cd #{script_file_path} && curl https://raw.githubusercontent.com/tonlabs/TON-SDK/master/tools/api.json > api.json`
+api_json_path = "#{script_file_path}/../../api.json"
+json = ''
+if File.exists?(api_json_path)
+  json = File.read(api_json_path)
+else
+  p "File #{api_json_path} is not exist"
+  exit 0
+end
+converter = ApiConverter.new(json)
+types = converter.convert
+generator = CodeGenerator.new(types, GEM_DIR)
+generator.generate_self_code
+
+version_file = "#{script_file_path}/../everscale-client-ruby/version.rb"
+file = File.read(version_file)
+
+p 'check version'
+if file[/VERSION = "(\d+)\.(\d+)\.(\d+)"/]
+  major = $1
+  minor = $2
+  current = $3
+  version = "#{major}.#{minor}.#{current.to_i + 1}"
+  p version
+  data = "module TonClient\n  VERSION = \"#{version}\"\nend\n\n"
+  p data
+  p version_file
+  File.open(version_file, 'wb') { |f| f.write(data) }
+  p 'update version'
+
+  puts "make release? Y/N"
+  option = gets
+  if option.strip.downcase == 'y'
+    system(%{cd #{GEM_DIR} && git add .})
+    system(%{cd #{GEM_DIR} && git commit -m 'version #{version}'})
+    system(%{cd #{GEM_DIR} && bash -lc 'rake release'})
+  end
+end
+

data/lib/everscale-client-ruby/Binding/binding.rb

@@ -0,0 +1,209 @@
+module TonClient
+  module TonBinding
+    @@request_id = 0
+    @@requests = {}
+
+    class Response
+      attr_reader :core
+      attr_accessor :result, :error, :custom_response, :finished, :request_id, :current_response
+
+      def initialize(core: TonClient::TonBinding)
+        @core = core
+      end
+
+      def update(request_id, string_data, response_type, finished)
+        response_hash = core.read_string_to_hash(string_data)
+        self.finished = finished
+        self.request_id = request_id
+        self.current_response = response_hash
+        case response_type
+        when 0
+          # result
+          self.result = response_hash
+        when 1
+          # error
+          self.error = response_hash
+        else
+          # another
+          if response_type >= 100
+            self.custom_responses = response_hash
+          end
+        end
+      end
+    end
+
+    def self.generate_request_id
+      @@request_id = 0 if @@request_id == 4294967295
+      @@request_id += 1
+    end
+
+    def self.get_request(id)
+      @@requests[id]
+    end
+
+    def self.delete_request(id)
+      @@requests[id] = nil
+    end
+
+    def self.set_request(id, &request_block)
+      @@requests[id] = request_block
+    end
+  end
+end
+
+
+module TonClient
+  
+  module TonBinding
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    
+    # memory allocators
+    attach_function :malloc, [:size_t], :pointer
+    attach_function :calloc, [:size_t], :pointer
+    attach_function :valloc, [:size_t], :pointer
+    attach_function :realloc, [:pointer, :size_t], :pointer
+    attach_function :free, [:pointer], :void
+    
+    # memory movers
+    attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+    attach_function :bcopy, [:pointer, :pointer, :size_t], :void
+    
+    def self.setup_bindings
+
+      # tc_string_handle_t* tc_create_context(tc_string_data_t config);
+      # attach_function :tc_create_context, [TcStringDataT.by_value], TcStringHandleT.by_ref
+      attach_function :tc_create_context, [TcStringDataT.by_value], :pointer
+
+      # fn tc_destroy_context(context: InteropContext)
+      attach_function :tc_destroy_context, [:uint32], :void
+
+      # 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, TcStringDataT.by_value, TcStringDataT.by_value], TcStringHandleT.by_ref
+      attach_function :tc_request_sync, [:uint32, TcStringDataT.by_value, TcStringDataT.by_value], :pointer
+
+      # enum tc_response_types_t {
+      #     tc_response_success = 0,
+      #     tc_response_error = 1,
+      #     tc_response_nop = 2,
+      #     tc_response_custom = 100,
+      # };
+      # 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_t, [:uint32, TcStringDataT.by_value, :uint32, :bool], :void
+
+      # 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);
+      attach_function :tc_request, [:uint32, TcStringDataT.by_value, TcStringDataT.by_value, :uint32, :tc_response_handler_t], :void
+
+      # tc_string_data_t tc_read_string(const tc_string_handle_t* handle);
+      # attach_function :tc_read_string, [TcStringHandleT.by_ref], TcStringDataT.by_value
+      attach_function :tc_read_string, [:pointer], TcStringDataT.by_value
+
+      # void tc_destroy_string(const tc_string_handle_t* handle)
+      # attach_function :tc_destroy_string, [TcStringHandleT.by_ref], :void
+      attach_function :tc_destroy_string, [:pointer], :void
+    end
+
+    def self.make_string(string)
+      result = TonBinding::TcStringDataT.new
+      result[:content] = FFI::MemoryPointer.from_string(string)
+      result[:len] = string.bytesize
+      result
+    end
+
+    # def self.read_string(tc_string_handle)
+    #   is_ref = tc_string_handle.class == TonClient::TonBinding::TcStringHandleT
+    #   if is_ref
+    #     string = tc_read_string(tc_string_handle)
+    #   else
+    #     string = tc_string_handle
+    #   end
+
+    #   if string[:content].address > 1
+    #     string = string[:content].read_string(string[:len]).force_encoding('UTF-8') + ''
+    #     tc_destroy_string(tc_string_handle) if is_ref
+    #     return string
+    #   end
+    #   nil
+    # end
+
+    def self.read_string(tc_string_handle)
+      is_ref = tc_string_handle.class == FFI::Pointer
+      if is_ref
+        string = tc_read_string(tc_string_handle)
+      else
+        string = tc_string_handle
+      end
+
+      if string[:content].address > 1
+        string = string[:content].read_string(string[:len]).force_encoding('UTF-8') + ''
+        tc_destroy_string(tc_string_handle) if is_ref
+        return string
+      end
+      nil
+    end
+
+    def self.read_string_to_hash(tc_string_handle_t_ref)
+      json_string = read_string(tc_string_handle_t_ref)
+      JSON.parse(json_string, {max_nesting: false}) if json_string
+    end
+
+    def self.send_request_sync(context: 1, method_name: '', payload: {})
+      raise 'context not found' unless context
+      raise 'method_name is empty' if method_name.empty?
+
+      method_name_string = make_string(method_name)
+      payload_string = make_string(payload.to_json)
+
+      sdk_json_response = tc_request_sync(context, method_name_string, payload_string)
+      response = read_string_to_hash(sdk_json_response)
+      
+      return response['result'] if response['result']
+      return response['error'] if response['error']
+    end
+
+    def self.send_request(context: 1, method_name: '', payload: {}, request_id: 1, &block)
+      raise 'context not found' unless context
+      raise 'method_name is empty' if method_name.empty?
+
+      if block
+        method_name_string = make_string(method_name)
+        payload_string = make_string(payload.to_json)
+        tc_request(context, method_name_string, payload_string, request_id, &block)
+      end
+    end
+
+    # block = { |response| }
+    def self.requestLibrary(context: 1, method_name: '', payload: {}, &block)
+      request_id = generate_request_id
+      set_request(request_id, &block)
+      send_request(context: context, method_name: method_name, payload: payload, request_id: request_id) do |request_id, string_data, response_type, finished|
+        if get_request(request_id)
+          response = Response.new
+          response.update(request_id, string_data, response_type, finished)
+          get_request(request_id).call(response)
+          delete_request(request_id) if finished
+        end
+      end
+    end
+
+  end
+end
+
+
+
+
+
+
+

data/lib/everscale-client-ruby/Binding/struct.rb

@@ -0,0 +1,21 @@
+module TonClient
+  module TonBinding
+    
+    # typedef struct {
+    #     const char* content;
+    #     uint32_t len;
+    # } tc_string_data_t;
+    class TcStringDataT < FFI::Struct
+      layout :content, :pointer,
+        :len, :uint32
+    end
+
+
+    # typedef struct  {
+    # } tc_string_handle_t;
+    class TcStringHandleT < FFI::Struct
+      layout :content, :pointer,
+        :len, :uint32
+    end
+  end
+end