ever_sdk_client 1.36.0

data/lib/ever_sdk_client/processing.rb

@@ -0,0 +1,268 @@
+module EverSdk
+  module Processing
+    #
+    # types
+    #
+
+    module ErrorCode
+      MESSAGE_ALREADY_EXPIRED = 501
+      MESSAGE_HAS_NOT_DESTINATION_ADDRESS = 502
+      CAN_NOT_BUILD_MESSAGE_CELL = 503
+      FETCH_BLOCK_FAILED = 504
+      SEND_MESSAGE_FAILED = 505
+      INVALID_MESSAGE_BOC = 506
+      MESSAGE_EXPIRED = 507
+      TRANSACTION_WAIT_TIMEOUT = 508
+      INVALID_BLOCK_RECEIVED = 509
+      CAN_NOT_CHECK_BLOCK_SHARD = 510
+      BLOCK_NOT_FOUND = 511
+      INVALID_DATA = 512
+      EXTERNAL_SIGNER_MUST_NOT_BE_USED = 513
+      MESSAGE_REJECTED = 514
+      INVALID_REMP_STATUS = 515
+      NEXT_REMP_STATUS_TIMEOUT = 516
+    end
+
+    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&.to_h,
+          send_events: send_events
+        }
+      end
+    end
+
+    ResultOfSendMessage = KwStruct.new(:shard_block_id)
+
+    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&.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 = %i[
+        will_fetch_first_block
+        fetch_first_block_failed
+        will_send
+        did_send
+        send_failed
+        will_fetch_next_block
+        fetch_next_block_failed
+        message_expired
+        remp_sent_to_validators
+        remp_included_into_block
+        remp_included_into_accepted_block
+        remp_other
+        remp_error
+      ]
+
+      attr_reader :type_, :error, :shard_block_id, :message_id, :message, :args
+
+      def initialize(type_:, error: nil, shard_block_id: nil, message_id: nil, message: nil, **args)
+        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
+        @args = args
+      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
+               }
+             when :remp_sent_to_validators, :remp_included_into_block, :remp_included_into_accepted_block, :remp_other, :remp_error
+               {
+                 message_id: message_id,
+                 timestamp: args[:timestamp],
+                 json: args[:json]
+               }
+             else
+               raise ArgumentError.new("unsupported type: #{@type_}")
+             end
+
+        h1.merge(h2)
+      end
+    end
+
+    DecodedOutput = KwStruct.new(:out_messages, :output) do
+      def initialize(out_messages:, output: nil)
+        super
+      end
+    end
+
+    ParamsOfProcessMessage = KwStruct.new(:message_encode_params, :send_events) do
+      def initialize(message_encode_params:, send_events:)
+        super
+      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,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfSendMessage.new(shard_block_id: 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,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfProcessMessage.new(
+              transaction: resp.result["transaction"],
+              out_messages: resp.result["out_messages"],
+              decoded: DecodedOutput.new(
+                out_messages: resp.result.dig("decoded", "out_messages"),
+                output: resp.result.dig("decoded", "output")
+              ),
+              fees: Tvm::TransactionFees.new(**resp.result["fees"].transform_keys(&:to_sym))
+            )
+          )
+        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,
+        client_callback: client_callback,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfProcessMessage.new(
+              transaction: resp.result["transaction"],
+              out_messages: resp.result["out_messages"],
+              decoded: DecodedOutput.new(
+                out_messages: resp.result.dig("decoded", "out_messages"),
+                output: resp.result.dig("decoded", "output")
+              ),
+              fees: Tvm::TransactionFees.new(**resp.result["fees"].transform_keys(&:to_sym))
+            )
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end

data/lib/ever_sdk_client/proofs.rb

@@ -0,0 +1,61 @@
+module EverSdk
+  module Proofs
+
+    #
+    # types
+    #
+
+    module ErrorCode
+      INVALID_DATA = 901
+      PROOF_CHECK_FAILED = 902
+      INTERNAL_ERROR = 903
+      DATA_DIFFERS_FROM_PROVEN = 904
+    end
+
+    ParamsOfProofBlockData = KwStruct.new(:block)
+
+    ParamsOfProofTransactionData = KwStruct.new(:transaction)
+
+    ParamsOfProofMessageData = KwStruct.new(:message)
+
+    #
+    # functions
+    #
+
+    def self.proof_block_data(ctx, params)
+      Interop::request_to_native_lib(ctx, "proofs.proof_block_data", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ""
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.proof_transaction_data(ctx, params)
+      Interop::request_to_native_lib(ctx, "proofs.proof_transaction_data", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ""
+          )
+        else
+          yield resp
+        end
+      end
+    end
+
+    def self.proof_message_data(ctx, params)
+      Interop::request_to_native_lib(ctx, "proofs.proof_message_data", params) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ""
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end

data/lib/ever_sdk_client/tvm.rb

@@ -0,0 +1,251 @@
+module EverSdk
+  module Tvm
+
+    #
+    # types
+    #
+
+    module ErrorCode
+      CANNOT_READ_TRANSACTION = 401
+      CANNOT_READ_BLOCKCHAIN_CONFIG = 402
+      TRANSACTION_ABORTED = 403
+      INTERNAL_ERROR = 404
+      ACTION_PHASE_FAILED = 405
+      ACCOUNT_CODE_MISSING = 406
+      LOW_BALANCE = 407
+      ACCOUNT_FROZEN_OR_DELETED = 408
+      ACCOUNT_MISSING = 409
+      UNKNOWN_EXECUTION_ERROR = 410
+      INVALID_INPUT_STACK = 411
+      INVALID_ACCOUNT_BOC = 412
+      INVALID_MESSAGE_TYPE = 413
+      CONTRACT_EXECUTION_ERROR = 414
+    end
+
+    ExecutionOptions = KwStruct.new(:blockchain_config, :block_time, :block_lt, :transaction_lt, :chksig_always_succeed) do
+      def initialize(blockchain_config: nil, block_time: nil, block_lt: nil, transaction_lt: nil, chksig_always_succeed: false)
+        super
+      end
+    end
+
+    class AccountForExecutor
+      private_class_method :new
+
+      TYPES = [:none, :uninit, :account]
+      attr_reader :type_, :boc, :unlimited_balance
+
+      def self.new_with_type_none
+        @type_ = :none
+      end
+
+      def self.new_with_type_uninit
+        @type_ = :uninit
+      end
+
+      def self.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
+
+    ParamsOfRunExecutor = KwStruct.new(
+      :message,
+      :account,
+      :execution_options,
+      :abi,
+      :skip_transaction_check,
+      :boc_cache,
+      :return_updated_account
+    ) do
+      def initialize(
+        message:,
+        account:,
+        execution_options: nil,
+        abi: nil,
+        skip_transaction_check: nil,
+        boc_cache: nil,
+        return_updated_account: nil
+      )
+        super
+      end
+
+      def to_h
+        h = super
+        h[:account] = self.account.to_h
+        h[:execution_options] = self.execution_options&.to_h
+        h[:abi] = self.abi&.to_h
+        h[:boc_cache] = self.boc_cache&.to_h
+        h
+      end
+    end
+
+    ResultOfRunExecutor = KwStruct.new(:transaction, :out_messages, :decoded, :account, :fees) do
+      def initialize(transaction:, out_messages:, decoded: nil, account:, fees:)
+        super
+      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
+        {
+          message: @message,
+          account: @account,
+          execution_options: @execution_options&.to_h,
+          abi: @abi&.to_h,
+          boc_cache: @boc_cache&.to_h,
+          return_updated_account: @return_updated_account
+        }
+      end
+    end
+
+    ResultOfRunTvm = KwStruct.new(:out_messages, :decoded, :account) do
+      def initialize(out_messages:, decoded: nil, account:)
+        super
+      end
+    end
+
+    class ParamsOfRunGet
+      attr_reader :account, :function_name, :input, :execution_options, :tuple_list_as_array
+
+      def initialize(account:, function_name:, input: nil, execution_options: nil, tuple_list_as_array: nil)
+        @account = account
+        @function_name = function_name
+        @input = input
+        @execution_options = execution_options
+        @tuple_list_as_array = tuple_list_as_array
+      end
+
+      def to_h
+        {
+          account: @account,
+          function_name: @function_name,
+          input: @input,
+          execution_options: @execution_options&.to_h,
+          tuple_list_as_array: @tuple_list_as_array
+        }
+      end
+    end
+
+    ResultOfRunGet = KwStruct.new(:output)
+
+    TransactionFees = KwStruct.new(
+      :in_msg_fwd_fee,
+      :storage_fee,
+      :gas_fee,
+      :out_msgs_fwd_fee,
+      :total_account_fees,
+      :total_output,
+      :ext_in_msg_fee,
+      :total_fwd_fees,
+      :account_fees
+    ) do
+      def initialize(
+        in_msg_fwd_fee:,
+        storage_fee:,
+        gas_fee:,
+        out_msgs_fwd_fee:,
+        total_account_fees:,
+        total_output:,
+        ext_in_msg_fee:,
+        total_fwd_fees:,
+        account_fees:
+      )
+        super
+      end
+    end
+
+
+    #
+    # functions
+    #
+
+    def self.run_executor(ctx, params)
+      Interop::request_to_native_lib(
+        ctx,
+        "tvm.run_executor",
+        params,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.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)
+      Interop::request_to_native_lib(
+        ctx,
+        "tvm.run_tvm",
+        params,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.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)
+      Interop::request_to_native_lib(
+        ctx,
+        "tvm.run_get",
+        params,
+        is_single_thread_only: false
+      ) do |resp|
+        if resp.success?
+          yield NativeLibResponseResult.new(
+            result: ResultOfRunGet.new(output: resp.result["output"])
+          )
+        else
+          yield resp
+        end
+      end
+    end
+  end
+end

data/lib/ever_sdk_client/types.rb

@@ -0,0 +1,45 @@
+module EverSdk
+  class ResultOfConvertAddress
+    attr_reader :address
+
+    def initialize(a)
+      @address = a
+    end
+  end
+
+  class SdkError < StandardError
+    attr_reader :code, :message, :data
+
+    def initialize(code: nil, message: nil, data: nil)
+      @code = code
+      @message = message
+      @data = data
+    end
+  end
+
+  class NativeLibResponseResult
+    attr_reader :result, :error
+
+    def initialize(result: nil, error: nil)
+      if !result.nil? && !error.nil?
+        raise ArgumentError.new('only either argument, result or error, should be specified')
+      elsif !result.nil?
+        @result = result
+      elsif !error.nil?
+        @error = SdkError.new(
+          code: error["code"],
+          message: error["message"],
+          data: error["data"]
+        )
+      else
+        # Some methods like unsubscribe will trigger this error. Should be refactored
+        raise ArgumentError.new('some arguments are wrong; provide either result or error')
+      end
+
+      self
+    end
+
+    def success? = !@result.nil?
+    def failure? = !@error.nil?
+  end
+end