ton-sdk-ruby 0.0.1

data/lib/ton-sdk-ruby/providers/provider.rb

@@ -0,0 +1,41 @@
+module TonSdkRuby
+  class Provider
+    attr_accessor :provider
+
+    def initialize(provider)
+      @provider = provider
+    end
+
+    def get_address_information(address)
+      provider.get_address_information(address)
+    end
+
+    def get_extended_address_information(address)
+      provider.get_extended_address_information(address)
+    end
+
+    def get_address_balance(address)
+      provider.get_address_balance(address)
+    end
+
+    def get_token_data(address)
+      provider.get_token_data(address)
+    end
+
+    def get_transactions(address, archival, limit, lt, hash, to_lt)
+      provider.get_transactions(address, archival, limit, lt, hash, to_lt)
+    end
+
+    def run_get_method(address, method, stack = [])
+      provider.run_get_method(address, method, stack)
+    end
+
+    def send_boc(boc)
+      provider.send_boc(boc)
+    end
+
+    def estimate_fee(address, body, init_code, init_data, ignore_chksig = false)
+      provider.estimate_fee(address, body, init_code, init_data, ignore_chksig)
+    end
+  end
+end

data/lib/ton-sdk-ruby/providers/toncenter.rb

@@ -0,0 +1,71 @@
+module TonSdkRuby
+
+  class TonCenter
+    URL = 'https://toncenter.com/api/v2/jsonRPC'
+    attr_accessor :api_key, :url
+
+    def initialize(url = nil, api_key)
+      @url = url || URL
+      @api_key = api_key
+    end
+
+    def send_request(metod, params)
+      headers = {
+        "X-API-Key": api_key
+      }
+      body = jrpc_wrap(metod, params)
+      read_post_json_from_link(url, body, headers)
+    end
+
+    def get_address_information(address)
+      send_request('getAddressInformation', {address: address})
+    end
+
+    def get_address_balance(address)
+      send_request('getAddressBalance', {address: address})
+    end
+
+    def get_address_state(address)
+      send_request('getAddressState', {address: address})
+    end
+
+    def get_token_data(address)
+      send_request('getTokenData', {address: address})
+    end
+
+    def get_transactions(address, archival, limit, lt, hash, to_lt)
+      params = {
+        address: address, archival: archival, limit: limit, lt: lt, hash: hash, to_lt: to_lt
+      }
+      send_request('getTransactions', params)
+    end
+
+    def run_get_method(address, method, stack = [])
+      params = {
+        address: address, method: method, stack: stack
+      }
+      send_request('runGetMethod', params)
+    end
+
+    def send_boc(boc)
+      send_request('sendBoc', {boc: boc})
+    end
+
+    def estimate_fee(address, body, init_code, init_data, ignore_chksig = false)
+      params = {
+        address: address, body: body, init_code: init_code, init_data: init_data, ignore_chksig: ignore_chksig
+      }
+      send_request('estimateFee', params)
+    end
+
+    private
+    def jrpc_wrap(method, params = {})
+      {
+        id: '1',
+        jsonrpc: '2.0',
+        method: method,
+        params: params.compact
+      }
+    end
+  end
+end

data/lib/ton-sdk-ruby/types/address.rb

@@ -0,0 +1,203 @@
+require 'base64'
+
+module TonSdkRuby
+
+  FLAG_BOUNCEABLE = 0x11
+  FLAG_NON_BOUNCEABLE = 0x51
+  FLAG_TEST_ONLY = 0x80
+
+  class Address
+    NONE = nil
+
+    class Type
+      BASE64 = 'base64'
+      RAW = 'raw'
+    end
+
+    attr_reader :hash, :workchain, :bounceable, :test_only, :type
+
+    def hash
+      Array.new(@hash)
+    end
+
+    def initialize(address, options = {})
+      options = {workchain: 0, bounceable: false, test_only: false}.merge(options)
+      is_address = Address.is_address?(address)
+      is_encoded = Address.is_encoded?(address)
+      is_raw = Address.is_raw?(address)
+
+      case true
+      when is_address
+        result = Address.parse_address(address)
+      when is_encoded
+        result = Address.parse_encoded(address)
+      when is_raw
+        result = Address.parse_raw(address)
+      else
+        raise 'Address: can\'t parse address. Unknown type.'
+      end
+
+      if result.nil?
+        raise 'Address: can\'t parse address. Unknown type.'
+      end
+
+      @workchain = options[:workchain] || result[:workchain]
+      @bounceable = options[:bounceable] || result[:bounceable]
+      @test_only = options[:test_only] || result[:test_only]
+      @hash = result[:hash]
+    end
+
+    def self.encode_tag(options)
+      bounceable = options[:bounceable]
+      test_only = options[:test_only]
+      tag = bounceable ? FLAG_BOUNCEABLE : FLAG_NON_BOUNCEABLE
+
+      test_only ? (tag | FLAG_TEST_ONLY) : tag
+    end
+
+    def self.decode_tag(tag)
+      data = tag
+      test_only = (data & FLAG_TEST_ONLY) != 0
+
+      if test_only
+        data ^= FLAG_TEST_ONLY
+      end
+
+      if ![FLAG_BOUNCEABLE, FLAG_NON_BOUNCEABLE].include?(data)
+        raise 'Address: bad address tag.'
+      end
+
+      bounceable = data == FLAG_BOUNCEABLE
+
+      {
+        bounceable: bounceable,
+        test_only: test_only
+      }
+    end
+
+    def eq(address)
+      address == self ||
+        (bytes_compare(hash, address.hash) && workchain == address.workchain)
+    end
+
+    def to_s(options = {})
+      type = options[:type] || Type::BASE64
+      workchain = options[:workchain] || self.workchain
+      bounceable = options[:bounceable] || self.bounceable
+      test_only = options[:test_only] || self.test_only
+      url_safe = options.key?(:url_safe) ? options[:url_safe] : true
+
+      raise 'Address: workchain must be int8.' unless workchain.is_a?(Numeric) && workchain >= -128 && workchain < 128
+      raise 'Address: bounceable flag must be a boolean.' unless [true, false].include?(bounceable)
+      raise 'Address: testOnly flag must be a boolean.' unless [true, false].include?(test_only)
+      raise 'Address: urlSafe flag must be a boolean.' unless [true, false].include?(url_safe)
+
+      if type == Type::RAW
+        "#{workchain}:#{bytes_to_hex(hash)}"
+      else
+        tag = Address.encode_tag(bounceable: bounceable, test_only: test_only)
+        address = [tag, workchain] + hash
+        checksum = crc16_bytes_be(address)
+        base64 = bytes_to_base64(address + checksum)
+
+        if url_safe
+          base64 = base64.tr('/', '_').tr('+', '-')
+        else
+          base64 = base64.tr('_', '/').tr('-', '+')
+        end
+
+        base64
+      end
+    end
+
+
+
+    private
+
+    def self.is_encoded?(address)
+      re = /^([a-zA-Z0-9_-]{48}|[a-zA-Z0-9\/\+]{48})$/
+      address.is_a?(String) && re.match?(address)
+    end
+
+    def self.is_raw?(address)
+      re = /^-?[0-9]:[a-zA-Z0-9]{64}$/
+      address.is_a?(String) && re.match?(address)
+    end
+
+    def self.parse_encoded(value)
+      base64 = value.tr('-', '+').tr('_', '/')
+      bytes = base64_to_bytes(base64)
+      data = Array.new(bytes)
+      address = data.shift(34)
+      checksum = data.shift(2)
+      crc = crc16_bytes_be(address)
+
+      raise 'Address: can\'t parse address. Wrong checksum.' unless bytes_compare(crc, checksum)
+
+      buffer = address.shift(2).pack('C2')
+
+      tag_and_wc = buffer.unpack('CS>')
+      tag = tag_and_wc.first
+      workchain = tag_and_wc.last.to_i
+
+      hash = address.shift(32)
+
+      decoded_tag = decode_tag(tag)
+      bounceable = decoded_tag[:bounceable]
+      test_only = decoded_tag[:test_only]
+
+      {
+        bounceable: bounceable,
+        test_only: test_only,
+        workchain: workchain,
+        hash: hash,
+        type: Type::BASE64
+      }
+    end
+
+    def self.parse_address(value)
+      workchain = value.workchain
+      bounceable = value.bounceable
+      test_only = value.test_only
+      hash = value.hash.clone
+      type = value.type
+
+      {
+        bounceable: bounceable,
+        test_only: test_only,
+        workchain: workchain,
+        hash: hash,
+        type: type
+      }
+    end
+
+    def self.parse_raw(value)
+      data = value.split(':')
+      workchain = data[0].to_i
+      hash = hex_to_bytes(data[1])
+      bounceable = false
+      test_only = false
+
+      {
+        bounceable: bounceable,
+        test_only: test_only,
+        workchain: workchain,
+        hash: hash,
+        type: Type::RAW
+      }
+    end
+
+    def self.is_address?(address)
+      address.is_a?(Address)
+    end
+
+    def self.is_valid?(address)
+      begin
+        new(address)
+        true
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/ton-sdk-ruby/types/block.rb

@@ -0,0 +1,388 @@
+module TonSdkRuby
+  class TickTockOptions
+    attr_accessor :tick, :tock
+
+    def initialize(tick, tock)
+      @tick = tick
+      @tock = tock
+    end
+  end
+
+  class SimpleLibOptions
+    attr_accessor :public, :root
+
+    def initialize(public_value, root_value)
+      @public = public_value
+      @root = root_value
+    end
+  end
+
+  class TickTock
+    attr_reader :data, :cell
+
+    def initialize(options)
+      @data = options
+      @cell = Builder.new
+                     .store_bit(options[:tick])
+                     .store_bit(options[:tock])
+                     .cell
+    end
+
+    def self.parse(cs)
+      tick = cs.load_bit == 1
+      tock = cs.load_bit == 1
+      options = { tick: tick, tock: tock }
+      new(options)
+    end
+  end
+
+  class SimpleLib
+    attr_reader :data, :cell
+
+    def initialize(options)
+      @data = options
+      @cell = Builder.new
+                     .store_bit(options[:public])
+                     .store_ref(options[:root])
+                     .cell
+    end
+
+    def self.parse(cs)
+      simple_lib = SimpleLib.new(
+        public: cs.load_bit == 1,
+        root: cs.load_ref
+      )
+      simple_lib
+    end
+  end
+
+  class StateInitOptions
+    attr_accessor :split_depth, :special, :code, :data, :library
+
+    def initialize(options = {})
+      @split_depth = options[:split_depth]
+      @special = options[:special]
+      @code = options[:code]
+      @data = options[:data]
+      @library = options[:library]
+    end
+  end
+
+  class StateInit
+    attr_reader :data, :cell
+
+    def initialize(state_init_options)
+      @data = state_init_options
+
+      b = Builder.new
+
+      # split_depth
+      if data.split_depth
+        b.store_uint(data.split_depth, 5)
+      else
+        b.store_bit(0)
+      end
+
+      # special
+      b.store_maybe_ref(data.special&.cell)
+      # code
+      b.store_maybe_ref(data.code)
+      b.store_maybe_ref(data.data)
+      b.store_dict(data.library)
+
+      @cell = b.cell
+    end
+
+    def self.parse(cs)
+      options = StateInitOptions.new()
+
+      options.split_depth = cs.load_bit.nonzero? ? cs.load_uint(5) : nil
+      options.special = TickTock.parse(cs) if cs.load_bit.nonzero?
+      options.code = cs.load_ref if cs.load_bit.nonzero?
+      options.data = cs.load_ref if cs.load_bit.nonzero?
+
+      deserializers = {
+        key: ->(k) { k },
+        value: ->(v) { SimpleLib.parse(Slice.parse(v.parse)) }
+      }
+
+      options.library = HashmapE.parse(256, cs, deserializers)
+
+      new(options)
+    end
+  end
+
+  class IntMsgInfo
+    attr_accessor :tag, :ihr_disabled, :bounce, :bounced, :src, :dest, :value,
+                  :ihr_fee, :fwd_fee, :created_lt, :created_at
+
+    def initialize(options = {})
+      @tag = 'int_msg_info'
+      @ihr_disabled = options[:ihr_disabled]
+      @bounce = options[:bounce]
+      @bounced = options[:bounced]
+      @src = options[:src]
+      @dest = options[:dest]
+      @value = options[:value]
+      @ihr_fee = options[:ihr_fee]
+      @fwd_fee = options[:fwd_fee]
+      @created_lt = options[:created_lt]
+      @created_at = options[:created_at]
+    end
+  end
+
+  class ExtInMsgInfo
+    attr_accessor :tag, :src, :dest, :import_fee
+
+    def initialize(options = {})
+      @tag = 'ext_in_msg_info'
+      @src = options[:src]
+      @dest = options[:dest]
+      @import_fee = options[:import_fee]
+    end
+  end
+
+  class CommonMsgInfo
+    attr_reader :data, :cell
+
+    def initialize(data)
+      case data.tag
+      when 'int_msg_info'
+        int_msg_info(data)
+      when 'ext_in_msg_info'
+        ext_in_msg_info(data)
+      else
+        raise 'OutAction: unexpected tag'
+      end
+    end
+
+    private
+
+    def int_msg_info(data)
+      b = Builder.new
+                 .store_bits([0]) # int_msg_info$0
+                 .store_bit(data.ihr_disabled || false) # ihr_disabled:Bool
+                 .store_bit(data.bounce) # bounce:Bool
+                 .store_bit(data.bounced || false) # bounced:Bool
+                 .store_address(data.src || Address::NONE) # src:MsgAddressInt
+                 .store_address(data.dest) # dest:MsgAddressInt
+                 .store_coins(data.value) # value: -> grams:Grams
+                 .store_bit(0) # value: -> other:ExtraCurrencyCollection
+                 .store_coins(data.ihr_fee || Coins.new(0)) # ihr_fee:Grams
+                 .store_coins(data.fwd_fee || Coins.new(0)) # fwd_fee:Grams
+                 .store_uint(data.created_lt || 0, 64) # created_lt:uint64
+                 .store_uint(data.created_at || 0, 32) # created_at:uint32
+
+      @data = data
+      @cell = b.cell
+    end
+
+    def ext_in_msg_info(data)
+      b = Builder.new
+                 .store_bits([1, 0]) # ext_in_msg_info$10
+                 .store_address(data.src || Address::NONE) # src:MsgAddress
+                 .store_address(data.dest) # dest:MsgAddressExt
+                 .store_coins(data.import_fee || Coins.new(0)) # import_fee:Grams
+
+      @data = data
+      @cell = b.cell
+    end
+
+    public
+
+    def self.parse(cs)
+      frst = cs.load_bit
+
+      if frst == 1
+        scnd = cs.load_bit
+        raise 'CommonMsgInfo: ext_out_msg_info unimplemented' if scnd == 1
+
+        return new(ExtInMsgInfo.new(
+          tag: 'ext_in_msg_info',
+          src: cs.load_address,
+          dest: cs.load_address,
+          import_fee: cs.load_coins
+        ))
+      end
+
+      if frst == 0
+        data = IntMsgInfo.new({
+                                tag: 'int_msg_info',
+                                ihr_disabled: cs.load_bit == 1,
+                                bounce: cs.load_bit == 1,
+                                bounced: cs.load_bit == 1,
+                                src: cs.load_address,
+                                dest: cs.load_address,
+                                value: cs.load_coins
+                              })
+
+        # TODO: support with ExtraCurrencyCollection
+        cs.skip_bits(1)
+
+        data.ihr_fee = cs.load_coins
+        data.fwd_fee = cs.load_coins
+        data.created_lt = cs.load_uint(64)
+        data.created_at = cs.load_uint(32)
+
+        return new(data)
+      end
+
+      raise 'CommonMsgInfo: invalid tag'
+    end
+  end
+
+  class MessageOptions
+    attr_accessor :info, :init, :body
+
+    def initialize(options = {})
+      @info = options[:info]
+      @init = options[:init]
+      @body = options[:body]
+    end
+  end
+
+  class Message
+    attr_reader :data, :cell
+
+    def initialize(options)
+      @data = options
+      b = Builder.new
+      b.store_slice(data.info.cell.parse) # info:CommonMsgInfo
+
+      # init:(Maybe (Either StateInit ^StateInit))
+      if data.init
+        b.store_bits([1, 0])
+        b.store_slice(data.init.cell.parse)
+      else
+        b.store_bit(0)
+      end
+
+      # body:(Either X ^X)
+      if data.body
+        if (b.bits.length + data.body.bits.length + 1 <= 1023) &&
+          (b.refs.length + data.body.refs.length <= 4)
+          b.store_bit(0)
+          b.store_slice(data.body.parse)
+        else
+          b.store_bit(1)
+          b.store_ref(data.body)
+        end
+      else
+        b.store_bit(0)
+      end
+
+      @cell = b.cell
+    end
+
+    def self.parse(cs)
+      data = {}
+      data.info = CommonMsgInfo.parse(cs)
+
+      if cs.load_bit
+        init = cs.load_bit ? cs.load_ref.parse : cs
+        data.init = StateInit.parse(init)
+      end
+
+      if cs.load_bit
+        data.body = cs.load_ref
+      else
+        data.body = Builder.new.store_slice(cs).cell
+      end
+
+      new(data)
+    end
+  end
+
+  class ActionSendMsg
+    attr_reader :tag, :mode, :out_msg
+
+    def initialize(options)
+      @tag = 'action_send_msg'
+      @mode = options[:mode]
+      @out_msg = options[:out_msg]
+    end
+  end
+
+  class ActionSetCode
+    attr_reader :tag, :new_code
+
+    def initialize(options)
+      @tag = 'action_set_code'
+      @new_code = options[:new_code]
+    end
+  end
+
+  class OutAction
+    def initialize(data)
+      case data.tag
+      when 'action_send_msg' then action_send_msg(data)
+      when 'action_set_code' then action_set_code(data)
+      else
+        raise 'OutAction: unexpected tag'
+      end
+    end
+
+    private def action_send_msg(data)
+      b = Builder.new
+      b.store_uint(0x0ec3c86d, 32)
+      b.store_uint(data.mode, 8)
+      b.store_ref(data.out_msg.cell)
+      @data = data
+      @cell = b.cell
+    end
+
+    private def action_set_code(data)
+      b = Builder.new
+      b.store_uint(0xad4de08e, 32)
+      b.store_ref(data.new_code)
+      @data = data
+      @cell = b.cell
+    end
+
+    def self.parse(cs)
+      tag = cs.load_uint(32)
+      data = {}
+
+      case tag
+      when 0x0ec3c86d # action_send_msg
+        mode = cs.load_uint(8)
+        out_msg = cs.load_ref.parse
+        data = ActionSendMsg.new({ tag: 'action_send_msg', mode: mode, out_msg: Message.parse(out_msg) })
+      when 0xad4de08e # action_set_code
+        data = ActionSetCode.new({ tag: 'action_set_code', new_code: cs.load_ref })
+      else
+        raise 'OutAction: unexpected tag'
+      end
+
+      OutAction.new(data)
+    end
+
+    attr_reader :data, :cell
+  end
+
+  class OutListOptions
+    attr_reader :actions
+
+    def initialize(options)
+      @actions = options[:actions]
+    end
+  end
+
+  class OutList
+
+    attr_reader :cell, :data
+    def initialize(action)
+      @data = action
+      cur = Builder.new.cell
+
+      data.actions.each do |a|
+        cur = Builder.new
+                      .store_ref(cur)
+                      .store_slice(a.cell.parse)
+                      .cell
+      end
+
+      @cell = cur
+    end
+  end
+end