ever_sdk_client 1.36.0

data/lib/ever_sdk_client/boc.rb

@@ -0,0 +1,416 @@
+module EverSdk
+  module Boc
+
+    #
+    # types
+    #
+
+    ParamsOfParse = KwStruct.new(:boc)
+    ResultOfParse = KwStruct.new(:parsed)
+    ParamsOfParseShardstate = KwStruct.new(:boc, :id, :workchain_id)
+    ParamsOfGetBlockchainConfig = KwStruct.new(:block_boc)
+    ResultOfGetBlockchainConfig = KwStruct.new(:config_boc)
+
+    ParamsOfGetBocHash = KwStruct.new(:boc)
+    ResultOfGetBocHash = KwStruct.new(:hash)
+
+    ParamsOfGetBocDepth = KwStruct.new(:boc)
+    ResultOfGetBocDepth = KwStruct.new(:depth)
+
+    ParamsOfGetCodeFromTvc = KwStruct.new(:tvc)
+    ResultOfGetCodeFromTvc = KwStruct.new(:code)
+    ParamsOfBocCacheGet = KwStruct.new(:boc_ref)
+
+    ResultOfBocCacheGet = KwStruct.new(:boc)
+
+    class BocCacheType
+      TYPES = [
+        :pinned,
+        :unpinned
+      ]
+
+      attr_reader :type, :pin
+
+      def initialize(type:, pin: nil)
+        unless TYPES.include?(type)
+          raise ArgumentError.new("type #{type} is unknown; known types: #{TYPES}")
+        end
+        @type = type
+        @pin = pin
+      end
+
+      def to_h
+        hash = {type: Helper.sym_to_capitalized_case_str(type)}
+        hash[:pin] = pin if type == :pinned
+        hash
+      end
+    end
+
+    ParamsOfBocCacheSet = KwStruct.new(:boc, :cache_type) do
+      def to_h
+        {
+          boc: boc,
+          cache_type: cache_type.to_h
+        }
+      end
+    end
+
+    ResultOfBocCacheSet = KwStruct.new(:boc_ref)
+    ParamsOfBocCacheUnpin = KwStruct.new(:pin, :boc_ref)
+    ParamsOfEncodeBoc = KwStruct.new(:builder, :boc_cache)
+    ResultOfEncodeBoc = KwStruct.new(:boc)
+
+    ParamsOfGetCodeSalt = KwStruct.new(:code, :boc_cache) do
+      def to_h
+        {
+          code: code,
+          boc_cache: boc_cache&.to_h
+        }
+      end
+    end
+
+    ResultOfGetCodeSalt = KwStruct.new(:salt)
+
+    ParamsOfSetCodeSalt = KwStruct.new(:code, :salt, :boc_cache) do
+      def to_h
+        {
+          code: code,
+          salt: salt,
+          boc_cache: boc_cache&.to_h
+        }
+      end
+    end
+
+    ResultOfSetCodeSalt = KwStruct.new(:code)
+
+    ParamsOfDecodeTvc = KwStruct.new(:tvc, :boc_cache) do
+      def to_h
+        {
+          tvc: tvc,
+          boc_cache: boc_cache&.to_h
+        }
+      end
+    end
+
+    ResultOfDecodeTvc = KwStruct.new(
+      :code,
+      :code_hash,
+      :code_depth,
+      :data,
+      :data_hash,
+      :data_depth,
+      :library,
+      :tick,
+      :tock,
+      :split_depth,
+      :compiler_version
+    )
+
+    ParamsOfEncodeTvc = KwStruct.new(
+      :code,
+      :data,
+      :library,
+      :tick,
+      :tock,
+      :split_depth,
+      :boc_cache
+    ) do
+      def to_h
+        {
+          code: code,
+          data: data,
+          library: library,
+          tick: tick,
+          tock: tock,
+          split_depth: split_depth,
+          boc_cache: boc_cache&.to_h
+        }
+      end
+    end
+
+    ResultOfEncodeTvc = KwStruct.new(:tvc)
+
+    ParamsOfEncodeExternalInMessage = KwStruct.new(:src, :dst, :init, :body, :boc_cache) do
+      def to_h
+        {
+          src: src,
+          dst: dst,
+          init: init,
+          body: body,
+          boc_cache: boc_cache&.to_h
+        }
+      end
+    end
+
+    ResultOfEncodeExternalInMessage = KwStruct.new(:message, :message_id)
+
+    ParamsOfGetCompilerVersion = KwStruct.new(:code)
+
+    ResultOfGetCompilerVersion = KwStruct.new(:version)
+
+    #
+    # functions
+    #
+
+    def self.parse_message(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.parse_message", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfParse.new(parsed: resp.result["parsed"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.parse_transaction(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.parse_transaction", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfParse.new(parsed: resp.result["parsed"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.parse_account(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.parse_account", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfParse.new(parsed: resp.result["parsed"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.parse_block(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.parse_block", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfParse.new(parsed: resp.result["parsed"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.parse_shardstate(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.parse_shardstate", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfParse.new(parsed: resp.result["parsed"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.get_boc_hash(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.get_boc_hash", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfGetBocHash.new(hash: resp.result["hash"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.get_blockchain_config(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.get_blockchain_config", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfGetBlockchainConfig.new(
+              config_boc: resp.result["config_boc"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.get_boc_depth(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.get_boc_depth", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfGetBocDepth.new(
+              depth: resp.result["depth"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.get_code_from_tvc(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.get_code_from_tvc", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfGetCodeFromTvc.new(code: resp.result["code"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.cache_get(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.cache_get", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfBocCacheGet.new(
+              boc: resp.result["boc"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.cache_set(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.cache_set", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfBocCacheSet.new(
+              boc_ref: resp.result["boc_ref"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.cache_unpin(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.cache_unpin", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: nil
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.encode_boc(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.encode_boc", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfEncodeBoc.new(
+              boc: resp.result["boc"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.get_code_salt(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.get_code_salt", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfGetCodeSalt.new(
+              salt: resp.result["salt"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.set_code_salt(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.set_code_salt", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfSetCodeSalt.new(
+              code: resp.result["code"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.decode_tvc(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.decode_tvc", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfDecodeTvc.new(
+              code: resp.result["code"],
+              code_depth: resp.result["code_depth"],
+              code_hash: resp.result["code_hash"],
+              data: resp.result["data"],
+              data_depth: resp.result["data_depth"],
+              data_hash: resp.result["data_hash"],
+              library: resp.result["library"],
+              tick: resp.result["tick"],
+              tock: resp.result["tock"],
+              split_depth: resp.result["split_depth"],
+              compiler_version: resp.result["compiler_version"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.encode_tvc(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.encode_tvc", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfEncodeTvc.new(
+              tvc: resp.result["tvc"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.encode_external_in_message(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.encode_external_in_message", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfEncodeExternalInMessage.new(
+              message: resp.result["message"],
+              message_id: resp.result["message_id"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.get_compiler_version(ctx, params)
+      Interop::request_to_native_lib(ctx, "boc.get_compiler_version", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfGetCompilerVersion.new(
+              version: resp.result["version"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end

data/lib/ever_sdk_client/client.rb

@@ -0,0 +1,180 @@
+require 'json'
+require_relative './interop.rb'
+
+module EverSdk
+  module Client
+
+    #
+    # types
+    #
+
+    module ErrorCode
+      NOT_IMPLEMENTED = 1
+      INVALID_HEX = 2
+      INVALID_BASE64 = 3
+      INVALID_ADDRESS = 4
+      CALLBACK_PARAMS_CANT_BE_CONVERTED_TO_JSON = 5
+      WEBSOCKET_CONNECT_ERROR = 6
+      WEBSOCKET_RECEIVE_ERROR = 7
+      WEBSOCKET_SEND_ERROR = 8
+      HTTP_CLIENT_CREATE_ERROR = 9
+      HTTP_REQUEST_CREATE_ERROR = 10
+      HTTP_REQUEST_SEND_ERROR = 11
+      HTTP_REQUEST_PARSE_ERROR = 12
+      CALLBACKNOTREGISTERED = 13
+      NET_MODULE_NOT_INIT = 14
+      INVALID_CONFIG = 15
+      CANNOT_CREATE_RUNTIME = 16
+      INVALID_CONTEXT_HANDLE = 17
+      CANNOT_SERIALIZE_RESULT = 18
+      CANNOT_SERIALIZE_ERROR = 19
+      CANNOT_CONVERT_JS_VALUE_TO_JSON = 20
+      CANNOT_RECEIVE_SPAWNED_RESULT = 21
+      SET_TIMER_ERROR = 22
+      INVALID_PARAMS = 23
+      CONTRACTS_ADDRESS_CONVERSION_FAILED = 24
+      UNKNOWN_FUNCTION = 25
+      APP_REQUEST_ERROR = 26
+      NO_SUCH_REQUEST = 27
+      CANNOT_SEND_REQUEST_RESULT = 28
+      CANNOT_RECEIVE_REQUEST_RESULT = 29
+      CANNOT_PARSE_REQUEST_RESULT = 30
+      UNEXPECTED_CALLBACK_RESPONSE = 31
+      CANNOT_PARSE_NUMBER = 32
+      INTERNAL_ERROR = 33
+      INVALID_HANDLE = 34
+      LOCAL_STORAGE_ERROR = 35
+    end
+
+    ResultOfVersion = KwStruct.new(:version)
+    ResultOfGetApiReference = KwStruct.new(:api)
+
+    BuildInfoDependency = KwStruct.new(:name, :git_commit) do
+      def self.from_json(j)
+        return nil if j.nil?
+
+        self.new(name: j["name"], git_commit: j["git_commit"])
+      end
+    end
+
+    ResultOfBuildInfo = KwStruct.new(:build_number, :dependencies)
+    ParamsOfAppRequest = KwStruct.new(:app_request_id, :request_data)
+
+    class AppRequestResult
+      TYPES = [:ok, :error]
+      attr_reader :type_, :text, :result
+
+      def initialize(type_:, result: nil, text: nil)
+        unless TYPES.include?(type_)
+          raise ArgumentError.new("type #{type_} is unknown; known types: #{TYPES}")
+        end
+        @type_ = type_
+
+        if !result.nil? && !text.nil?
+          raise ArgumentError.new("both 'result' and 'text' may not contain values at the same time")
+        end
+
+        if @type_ == :ok
+          @result = result
+        elsif @type_ == :error
+          @text = text
+        end
+      end
+
+      def to_h
+        {
+          type: Helper.sym_to_capitalized_case_str(@type_),
+
+          # may be either one instead?
+          result: @result,
+          text: @text
+        }
+      end
+    end
+
+    ParamsOfResolveAppRequest = KwStruct.new(:app_request_id, :result) do
+      def to_h
+        {
+          app_request_id: app_request_id,
+          result: result.to_h
+        }
+      end
+    end
+
+
+    #
+    # functions
+    #
+
+    # params:
+    # +ctx+:: +ClientContext+ object
+    def self.version(ctx)
+      Interop::request_to_native_lib(ctx, "client.version") do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfVersion.new(version: resp.result["version"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.config(ctx)
+      Interop::request_to_native_lib(ctx, "client.config") do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ClientConfig.new(
+              network: resp.result["network"],
+              crypto: resp.result["crypto"],
+              abi: resp.result["abi"],
+              boc: resp.result["boc"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.get_api_reference(ctx)
+      Interop::request_to_native_lib(ctx, "client.get_api_reference") do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfGetApiReference.new(api: resp.result["api"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.build_info(ctx)
+      Interop::request_to_native_lib(ctx, "client.build_info") do |resp|
+        if resp.success?
+          dp_s = resp.result["dependencies"].map { |x| BuildInfoDependency.from_json(x) }
+          yield NativeLibResponseResult.new(
+            result: ResultOfBuildInfo.new(
+              build_number: resp.result["build_number"],
+              dependencies: dp_s
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.resolve_app_request(ctx, params)
+      Interop::request_to_native_lib(ctx, "client.resolve_app_request", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ""
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end

data/lib/ever_sdk_client/client_context.rb

@@ -0,0 +1,55 @@
+require 'json'
+
+require_relative './kw_struct.rb'
+require_relative './interop.rb'
+require_relative './types.rb'
+require_relative './helper.rb'
+
+require_relative './config.rb'
+require_relative './client.rb'
+require_relative './utils.rb'
+require_relative './crypto.rb'
+require_relative './abi.rb'
+require_relative './boc.rb'
+require_relative './net.rb'
+require_relative './tvm.rb'
+require_relative './proofs.rb'
+require_relative './processing.rb'
+require_relative './debot.rb'
+
+
+module EverSdk
+  class ClientContext
+    attr_reader :context
+
+    def initialize(cfg_json)
+      cfg_json_tc_str = Interop::TcStringData::from_string(cfg_json)
+      ptr = Interop::tc_create_context(cfg_json_tc_str)
+      ctx_tc_str = Interop::tc_read_string(ptr)
+      if (ctx_tc_str != nil) && (ctx_tc_str[:len] > 0)
+        cont_str = ctx_tc_str[:content].read_string(ctx_tc_str[:len])
+        ctx_json = JSON.parse(cont_str)
+        ctx_val = ctx_json["result"]
+        if ctx_val != nil
+          @context = ctx_val
+          @requests = Concurrent::Hash.new()
+          ObjectSpace.define_finalizer(self, self.class.finalize(@context))
+        else
+          raise SdkError.new(message: "unable to create context: #{ctx_json}")
+        end
+
+        Interop::tc_destroy_string(ptr)
+      else
+        raise SdkError.new(message: "unable to create context")
+      end
+    end
+
+    def self.finalize(ctx)
+      Proc.new do
+        if (ctx != nil) && (ctx > 0)
+          Interop::tc_destroy_context(ctx)
+        end
+      end
+    end
+  end
+end