ton_sdk_client 1.7.1

data/lib/ton_sdk_client/processing.rb

@@ -0,0 +1,257 @@
+module TonSdk
+  module Processing
+
+    #
+    # types
+    #
+
+    class ParamsOfSendMessage
+      attr_reader :message, :abi, :send_events
+
+      def initialize(message:, abi: nil, send_events:)
+        @message = message
+        @abi = abi
+        @send_events = send_events
+      end
+
+      def to_h
+        {
+          message: @message,
+          abi: @abi.nil? ? nil : @abi.to_h,
+          send_events: @send_events
+        }
+      end
+    end
+
+    class ResultOfSendMessage
+      attr_reader :shard_block_id
+
+      def initialize(a)
+        @shard_block_id = a
+      end
+
+      def to_h
+        {
+          shard_block_id: @shard_block_id
+        }
+      end
+    end
+
+    class ParamsOfWaitForTransaction
+      attr_reader :abi, :message, :shard_block_id, :send_events
+
+      def initialize(abi: nil, message:, shard_block_id:, send_events:)
+        @abi = abi
+        @message = message
+        @shard_block_id = shard_block_id
+        @send_events = send_events
+      end
+
+      def to_h
+        {
+          abi: @abi.nil? ? nil : @abi.to_h,
+          message: @message,
+          shard_block_id: @shard_block_id,
+          send_events: @send_events
+        }
+      end
+    end
+
+    class ResultOfProcessMessage
+      attr_reader :transaction, :out_messages, :decoded, :fees
+
+      def initialize(transaction:, out_messages:, decoded: nil, fees:)
+        @transaction = transaction
+        @out_messages = out_messages
+        @decoded = decoded
+        @fees = fees
+      end
+
+      def to_h
+        {
+          transaction: @transaction,
+          out_messages: @out_messages,
+          decoded: @decoded,
+          fees: @fees
+        }
+      end
+    end
+
+    class ProcessingEvent
+      TYPES = [
+        :will_fetch_first_block,
+        :fetch_first_block_failed,
+        :will_send,
+        :did_send,
+        :send_failed,
+        :will_fetch_next_block,
+        :fetch_next_block_failed,
+        :message_expired
+      ]
+
+      attr_reader :type_, :error, :shard_block_id, :message_id, :message
+
+      def initialize(type_:, error: nil, shard_block_id: nil, message_id: nil, message: nil)
+        unless TYPES.include?(type_)
+          raise ArgumentError.new("type #{type_} is unknown; known types: #{TYPES}")
+        end
+        @type_ = type_
+        @error = error
+        @shard_block_id = shard_block_id
+        @message_id = message_id
+        @message = message
+      end
+
+      def to_h
+        h1 = {
+          type: @type
+        }
+
+        h2 = case @type_
+        when :will_fetch_first_block
+          { }
+        when :fetch_first_block_failed
+          { 
+            error: @error
+          }
+        when :will_send, :did_send, :will_fetch_next_block
+          {
+            shard_block_id: @shard_block_id,
+            message_id: @message_id,
+            message: @message
+          }
+        when :send_failed, :fetch_next_block_failed
+          {
+            shard_block_id: @shard_block_id,
+            message_id: @message_id,
+            message: @message,
+            error: @error
+          }
+        when :message_expired
+          {
+            message_id: @message_id,
+            message: @message,
+            error: @error
+          }
+        else
+          raise ArgumentError.new("unsupported type: #{@type_}")
+        end
+
+        h1.merge(h2)
+      end
+    end
+
+    class DecodedOutput
+      attr_reader :out_messages, :output
+
+      def initialize(out_messages:, output: nil)
+        @out_messages = out_messages
+        @output = output
+      end
+
+      def to_h
+        {
+          out_messages: @out_messages,
+          output: @output
+        }
+      end
+    end
+
+    class ParamsOfProcessMessage
+      attr_reader :message_encode_params, :send_events
+
+      def initialize(message_encode_params:, send_events:)
+        @message_encode_params = message_encode_params
+        @send_events = send_events
+      end
+
+      def to_h
+        {
+          message_encode_params: @message_encode_params.to_h,
+          send_events: @send_events
+        }
+      end
+    end
+
+
+    #
+    # functions
+    #
+
+    def self.send_message(ctx, params, client_callback = nil)
+      if (params.send_events == true) && client_callback.nil?
+        raise ArgumentError.new("with `send_events` set to true, `client_callback` may not be nil")
+      end
+
+      Interop::request_to_native_lib(
+        ctx,
+        "processing.send_message",
+        params.to_h.to_json,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfSendMessage.new(resp.result["shard_block_id"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.wait_for_transaction(ctx, params, client_callback = nil)
+      if (params.send_events == true) && client_callback.nil?
+        raise ArgumentError.new("with `send_events` set to true, `client_callback` may not be nil")
+      end
+
+      Interop::request_to_native_lib(
+        ctx,
+        "processing.wait_for_transaction",
+        params.to_h.to_json,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfProcessMessage.new(
+              transaction: resp.result["transaction"],
+              out_messages: resp.result["out_messages"],
+              decoded: resp.result["decoded"],
+              fees: resp.result["fees"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.process_message(ctx, params, client_callback = nil)
+      if (params.send_events == true) && client_callback.nil?
+        raise ArgumentError.new("with `send_events` set to true `client_callback` may not be nil")
+      end
+
+      Interop::request_to_native_lib(
+        ctx,
+        "processing.process_message",
+        params.to_h.to_json,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfProcessMessage.new(
+              transaction: resp.result["transaction"],
+              out_messages: resp.result["out_messages"],
+              decoded: resp.result["decoded"],
+              fees: resp.result["fees"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end

data/lib/ton_sdk_client/tvm.rb

@@ -0,0 +1,264 @@
+module TonSdk
+  module Tvm
+
+    #
+    # types
+    #
+
+    class ExecutionOptions
+      attr_reader :blockchain_config, :block_time, :block_lt, :transaction_lt
+
+      def initialize(blockchain_config: nil, block_time: nil, block_lt: nil, transaction_lt: nil)
+        @blockchain_config = blockchain_config
+        @block_time = block_time
+        @block_lt = block_lt
+        @transaction_lt = transaction_lt
+      end
+    end
+
+    class AccountForExecutor
+      TYPES = [:none, :uninit, :account]
+      attr_reader :type_, :boc, :unlimited_balance
+
+      def new_with_type_none
+        @type_ = :none
+      end
+
+      def new_with_type_uninit
+        @type_ = :uninit
+      end
+
+      def new_with_type_account(boc:, unlimited_balance: nil)
+        @type_ = :account
+        @boc = boc
+        @unlimited_balance = unlimited_balance
+      end
+
+      def to_h
+        h1 = case @type_
+        when :none, :uninit
+          {
+            type: Helper.sym_to_capitalized_case_str(@type_),
+          }
+        when :account
+          {
+            type: Helper.sym_to_capitalized_case_str(@type_),
+            boc: @boc,
+            unlimited_balance: @unlimited_balance
+          }
+        end
+      end
+    end
+
+    class ParamsOfRunExecutor
+      attr_reader :message, :account, :execution_options, :abi, :skip_transaction_check,
+                    :boc_cache, :return_updated_account
+
+      def initialize(
+        message:,
+        account:,
+        execution_options: nil,
+        abi: nil,
+        skip_transaction_check: nil,
+        boc_cache: nil,
+        return_updated_account: nil
+      )
+        @message = message
+        @account = account
+        @execution_options = execution_options
+        @abi = abi
+        @skip_transaction_check = skip_transaction_check
+        @boc_cache = boc_cache
+        @return_updated_account = return_updated_account
+      end
+
+      def to_h
+        abi_val = @abi.nil? ? nil : @abi.to_h
+        exe_opt_val = @execution_options.nil? ? nil : @execution_options.to_h
+        boc_cache_val = @boc_cache.nil? ? nil : @boc_cache.to_h
+
+        {
+          message: @message,
+          account: @account.to_h,
+          execution_options: exe_opt_val,
+          abi: abi_val,
+          skip_transaction_check: @skip_transaction_check,
+          boc_cache: boc_cache_val,
+          return_updated_account: @return_updated_account
+        }
+      end
+    end
+
+    class ResultOfRunExecutor
+      attr_reader :transaction, :out_messages, :decoded, :account, :fees
+
+      def initialize(transaction:, out_messages:, decoded: nil, account:, fees:)
+        @transaction = transaction
+        @out_messages = out_messages
+        @decoded = decoded
+        @account = account
+        @fees = fees
+      end
+    end
+
+    class ParamsOfRunTvm
+      attr_reader :message, :account, :execution_options, :abi,
+                    :boc_cache, :return_updated_account
+
+      def initialize(message:, account:, execution_options: nil, abi: nil, boc_cache: nil, return_updated_account: nil)
+        @message = message
+        @account = account
+        @execution_options = execution_options
+        @abi = abi
+        @boc_cache = boc_cache
+        @return_updated_account = return_updated_account
+      end
+
+      def to_h
+        abi_val = @abi.nil? ? nil : @abi.to_h
+        exe_opt_val = @execution_options.nil? ? nil : @execution_options.to_h
+        boc_cache_val = @boc_cache.nil? ? nil : @boc_cache.to_h
+
+        {
+          message: @message,
+          account: @account,
+          execution_options: exe_opt_val,
+          abi: abi_val,
+          boc_cache: boc_cache_val,
+          return_updated_account: @return_updated_account
+        }
+      end
+    end
+
+    class ResultOfRunTvm
+      attr_reader :out_messages, :decoded, :account
+
+      def initialize(out_messages:, decoded: nil, account:)
+        @out_messages = out_messages
+        @decoded = decoded
+        @account = account
+      end
+    end
+
+    class ParamsOfRunGet
+      attr_reader :account, :function_name, :input, :execution_options
+
+      def initialize(account:, function_name:, input: nil, execution_options: nil)
+        @account = account
+        @function_name = function_name
+        @input = input
+        @execution_options = execution_options
+      end
+
+      def to_h
+        exe_opt_val = @execution_options.nil? ? nil : @execution_options.to_h
+
+        {
+          account: @account,
+          function_name: @function_name,
+          input: @input,
+          execution_options: exe_opt_val
+        }
+      end
+    end
+
+    class ResultOfRunGet
+      attr_reader :output
+
+      def initialize(a)
+        @output = a
+      end
+    end
+
+    class TransactionFees
+      attr_reader :in_msg_fwd_fee, :storage_fee, :gas_fee, :out_msgs_fwd_fee,
+        :total_account_fees
+
+      def initialize(in_msg_fwd_fee:, storage_fee: , gas_fee:, out_msgs_fwd_fee:,
+        total_account_fees:, total_output:
+      )
+        @in_msg_fwd_fee = in_msg_fwd_fee
+        @storage_fee = storage_fee
+        @gas_fee = gas_fee
+        @out_msgs_fwd_fee = out_msgs_fwd_fee
+        @total_account_fees = total_account_fees
+        @total_output = total_output
+      end
+
+      def to_h
+        {
+          in_msg_fwd_fee: @in_msg_fwd_fee,
+          storage_fee: @storage_fee,
+          gas_fee: @gas_fee,
+          out_msgs_fwd_fee: @out_msgs_fwd_fee,
+          total_account_fees: @total_account_fees,
+          total_output: @total_output
+        }
+      end
+    end
+
+    def self.run_executor(ctx, params)
+      pr_json = params.to_h.to_json
+      Interop::request_to_native_lib(
+        ctx,
+        "tvm.run_executor",
+        pr_json,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfRunExecutor.new(
+              transaction: resp.result["transaction"],
+              out_messages: resp.result["out_messages"],
+              decoded: resp.result["decoded"],
+              account: resp.result["account"],
+              fees: resp.result["fees"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.run_tvm(ctx, params)
+      pr_json = params.to_h.to_json
+      Interop::request_to_native_lib(
+        ctx,
+        "tvm.run_tvm",
+        pr_json,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfRunTvm.new(
+              out_messages: resp.result["out_messages"],
+              decoded: resp.result["decoded"],
+              account: resp.result["account"]
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.run_get(ctx, params)
+      pr_json = params.to_h.to_json
+      Interop::request_to_native_lib(
+        ctx,
+        "tvm.run_get",
+        pr_json,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponsetResult.new(
+            result: ResultOfRunGet.new(resp.result["output"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end