ton-sdk-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f7fff8c0e9e038b0aacb1c5c68c3c39c1bbc293815fc296a01927ccf9798c0a7
+  data.tar.gz: 69d92e29e24377da266692e0a45656ed97e79bd4507d0e9b67807dd7b588b4b7
+SHA512:
+  metadata.gz: 91a850a5872fe1dd7d9737239b5610402361e8b29b3deb210c9bdc5221982015a42168e55f16076672c0fe599d4a11f94f8d3b2c04e4b41720e622e8c6869089
+  data.tar.gz: 04b2344e2377b1cdf507559eae021784ad04048646236b2df40a73a538350ac72482dd148da1d4993d2f964bd369ea5aad034e6f6e3f487e8adcd8fdefca9b3b

data/bin/ton-sdk-ruby

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+GEM_DIR = File.dirname(__FILE__) + '/..'
+
+if ARGV[0] == 'start'
+  p 'start'
+end

data/lib/ton-sdk-ruby/bit_array/bit_array.rb

@@ -0,0 +1,169 @@
+module TonSdkRuby
+  class BitArray < Array
+    
+    attr_accessor :read_cursor
+
+    def initialize(size: 0, value: false)
+      @read_cursor = 0
+      super(size) { |_| get_value(value) }
+    end
+
+    def to_s
+      self.map { |e| e ? 1 : 0 }.join('')
+    end
+
+    def show_cursor
+      self.map { |e| e ? 1 : 0 }.join('').insert(cursor, '⏶')
+    end
+
+    def set_bit!(index: nil, value: nil)
+      raise "Wrong index #{index}. Out of bounds array" if index > size || index < 0
+      self[index] = get_value(value)
+    end
+
+    def get_bit(index: nil)
+      raise "Wrong index #{index}. Out of bounds array" if index > size - 1 || index < 0
+      self[index]
+    end
+
+    def set_byte!(index: nil, value: nil)
+      set_number!(index: index, value: value, size: 8)
+    end
+
+    def get_byte(index: nil)
+      raise "Wrong index #{index}. Out of bounds array" if index > size - 1 || index < 0
+      self[index..index+7].map { |e| e.to_i}.join('').to_i(2)
+    end
+
+    def store_uint!(value: nil, size: nil)
+      store_number!(value: value, size: size)
+    end
+
+    def store_sint!(value: nil, size: nil)
+      # i.e. signed int and one first bit reserved for sign size = (size - 1) 
+      # and restrict for max value = value >= (1 << size - 1)
+      max_sint = (1 << size - 1)
+      raise "Wrong value #{value}" if value < -max_sint || value >= max_sint
+      set_number!(value: value, size: size)
+    end
+
+    def read_uint!(bits_amount: nil)
+      raise "Wrong bits_amount #{bits_amount}" if bits_amount > self.size
+      bits_string = ""
+      (read_cursor + bits_amount).times do |index|
+        bits_string << self[index] ? '1' : '0'
+        @read_cursor = index
+      end
+      bits_string.to_i(2)
+    end
+
+    def read_sint!(bits_amount: nil)
+      raise "Wrong bits_amount #{bits_amount}" if bits_amount > self.size
+      negative_sign = false
+      bits_string = ""
+      (read_cursor + bits_amount).times do |index|
+        bits_string << (self[index] ? '1' : '0')
+        @read_cursor = index
+      end
+      calc_signed_integer(bits_string: bits_string)
+    end
+
+
+    private
+
+    # 00001101 -> set as 00001101
+    def set_number!(index: nil, value: nil, size: nil)
+      index = index ? index : self.size
+      raise "Wrong index #{index}. Out of bounds array" if index > self.size || index < 0
+      # if size = 4 bit and max value in bits = 1111, then error (value >= 10000) == (value >= (1 << 4))
+      raise "Wrong value #{value}" if value >= (1 << size)
+      size.times do |i|
+        bit_index = size - i - 1
+        # if size = 4 bit and value in bots = 1000, then (1000 >> (4 - 1)) == 0001
+        most_significant_bit = (value >> bit_index)
+        # p most_significant_bit.to_s(2)
+        # & (AND) 101 & 1 == 001 or 101 & 001 == 001
+        bit = (most_significant_bit & 1) == 1
+        set_bit!(index: index, value: bit)
+        index += 1
+      end
+      self
+    end
+
+    # # 00001101 -> set as 00001101
+    # def store_number!(index: nil, value: nil, size: nil)
+    #   @cursor = index ? index : cursor
+    #   raise "Wrong index #{cursor}. Out of bounds array" if cursor > self.size || cursor < 0
+    #   # if size = 4 bit and max value in bits = 1111, then error (value >= 10000) == (value >= (1 << 4))
+    #   raise "Wrong value #{value}" if value < 0 || value >= (1 << size)
+    #   size.times do |i|
+    #     bit_index = size - i - 1
+    #     # if size = 4 bit and value in bots = 1000, then (1000 >> (4 - 1)) == 0001
+    #     most_significant_bit = (value >> bit_index)
+    #     # p most_significant_bit.to_s(2)
+    #     # & (AND) 101 & 1 == 001 or 101 & 001 == 001
+    #     bit = (most_significant_bit & 1) == 1
+    #     set_bit!(index: cursor, value: bit)
+    #     @cursor += 1
+    #   end
+    #   self
+    # end
+
+    def calc_signed_integer(bits_string: nil)
+      value = bits_string.to_i(2)
+      index = bits_string.size - 1
+      (value & ~(1 << index)) - (value & (1 << index))
+    end
+
+    def get_value(val)
+      if val.class == TrueClass
+        val
+      elsif val.class == FalseClass
+        val
+      elsif val.class == String
+        val == "1" ? true : false
+      elsif val.class == Integer
+        val == 0 ? false : true
+      else
+        raise "Wrong data type of #{val}"
+      end
+    end
+  end
+end
+
+class FalseClass
+  def to_i
+    0
+  end
+end
+
+class TrueClass
+  def to_i
+    1
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/ton-sdk-ruby/boc/builder.rb

@@ -0,0 +1,261 @@
+module TonSdkRuby
+  class Builder
+    attr_reader :size, :refs, :bits
+
+    def bytes
+      bits_to_bytes(@bits)
+    end
+
+    def remainder
+      size - bits.length
+    end
+
+    def initialize(size = 1023)
+      @size = size
+      @bits = []
+      @refs = []
+    end
+
+    def store_slice(slice)
+      require_type('slice', slice, Slice)
+      Builder.check_slice_type(slice)
+
+      bits = slice.bits
+      refs = slice.refs
+
+      check_bits_overflow(bits.length)
+      check_refs_overflow(refs.length)
+      store_bits(bits)
+
+      refs.each { |ref| store_ref(ref) }
+
+      self
+    end
+
+    def store_ref(ref)
+      require_type('ref', ref, Cell)
+      Builder.check_refs_type([ref])
+      check_refs_overflow(1)
+      @refs.push(ref)
+
+      self
+    end
+
+    def store_maybe_ref(ref = nil)
+      require_type('ref', ref, Cell) if ref
+      return store_bit(0) unless ref
+      store_bit(1).store_ref(ref)
+    end
+
+    def store_refs(refs)
+      Builder.check_refs_type(refs)
+      check_refs_overflow(refs.length)
+      @refs.push(*refs)
+
+      self
+    end
+
+    def store_bit(bit)
+      bit = bit.to_i
+      value = Builder.check_bits_type_and_normalize([bit])
+      check_bits_overflow(1)
+      @bits += value
+
+      self
+    end
+
+    def store_bits(bits)
+      require_type('bits', bits, Array)
+      require_type('bit', bits[0], Integer) if bits.size > 0
+      value = Builder.check_bits_type_and_normalize(bits)
+      check_bits_overflow(value.length)
+      @bits += value
+
+      self
+    end
+
+    def store_int(value, size)
+      int = value.is_a?(Integer) ? value : value.to_i
+      int_bits = 1 << (size - 1)
+
+      if int < -int_bits || int >= int_bits
+        raise StandardError.new("Builder: can't store an Int, because its value allocates more space than provided.")
+      end
+
+      store_number(int, size)
+
+      self
+    end
+
+    def store_uint(value, size)
+      uint = value.is_a?(Integer) ? value : value.to_i
+      if uint < 0 || uint >= (1 << size)
+        raise StandardError.new("Builder: can't store an UInt, because its value allocates more space than provided.")
+      end
+
+      store_number(uint, size)
+
+      self
+    end
+
+    def store_var_int(value, length)
+      int = value.is_a?(Integer) ? value : value.to_i
+      size = (Math.log2(length)).ceil
+      size_bytes = (int.to_s(2).length.to_f / 8).ceil
+      size_bits = size_bytes * 8
+
+      check_bits_overflow(size + size_bits)
+
+      if int == 0
+        store_uint(0, size)
+      else
+        store_uint(size_bytes, size).store_int(value, size_bits)
+      end
+
+      self
+    end
+
+    def store_var_uint(value, length)
+      uint = value.is_a?(Integer) ? value : value.to_i
+      size = (Math.log2(length)).ceil
+      size_bytes = (uint.to_s(2).length.to_f / 8).ceil
+      size_bits = size_bytes * 8
+
+      check_bits_overflow(size + size_bits)
+
+      if uint == 0
+        store_uint(0, size)
+      else
+        store_uint(size_bytes, size).store_uint(value, size_bits)
+      end
+
+      self
+    end
+
+    def store_bytes(value)
+      require_type('value', value, Array)
+      check_bits_overflow(value.size * 8)
+      value.each { |byte| store_uint(byte, 8) }
+
+      self
+    end
+
+    def store_string(value)
+      require_type('value', value, String)
+      bytes = string_to_bytes(value)
+
+      store_bytes(bytes)
+
+      self
+    end
+
+    def store_address(address = nil)
+      require_type('address', address, Address) if address
+      if address.nil?
+        store_bits([0, 0])
+        return self
+      end
+
+      anycast = 0
+      address_bits_size = 2 + 1 + 8 + 256
+
+      Builder.check_address_type(address)
+      check_bits_overflow(address_bits_size)
+      store_bits([1, 0])
+      store_uint(anycast, 1)
+      store_int(address.workchain, 8)
+      store_bytes(address.hash)
+
+      self
+    end
+
+    def store_coins(coins)
+      require_type('coins', coins, Coins)
+      if coins.negative?
+        raise 'Builder: coins value can\'t be negative.'
+      end
+
+      nano = coins.to_nano
+
+      # https://github.com/ton-blockchain/ton/blob/master/crypto/block/block.tlb#L116
+      store_var_uint(nano, 16)
+
+      self
+    end
+
+    def store_dict(hashmap = nil)
+      return store_bit(0) unless hashmap
+
+      slice = hashmap.cell.parse
+      store_slice(slice)
+
+      self
+    end
+
+    def clone
+      data = Builder.new(size)
+
+      # Use getters to get copy of arrays
+      data.store_bits(bits)
+      refs.each { |ref| data.store_ref(ref) }
+
+      data
+    end
+
+    def cell(type = CellType::Ordinary)
+      # Use getters to get copies of arrays
+      cell = Cell.new(bits: bits, refs: refs, type: type)
+
+      cell
+    end
+
+    private
+
+    def self.check_slice_type(slice)
+      unless slice.is_a?(Slice)
+        raise StandardError, "Builder: can't store slice, because it's type is not a Slice."
+      end
+    end
+
+    def self.check_address_type(address)
+      unless address.is_a?(Address)
+        raise StandardError, "Builder: can't store address, because it's type is not an Address."
+      end
+    end
+
+    def check_bits_overflow(size)
+      if size > remainder
+        raise StandardError.new("Builder: bits overflow. Can't add #{size} bits. Only #{remainder} bits left.")
+      end
+    end
+
+    def self.check_refs_type(refs)
+      unless refs.all? { |cell| cell.is_a?(Cell) }
+        raise StandardError, "Builder: can't store ref, because it's type is not a Cell."
+      end
+    end
+
+    def self.check_bits_type_and_normalize(bits)
+      bits.map do |bit|
+        unless [0, 1, false, true].include?(bit)
+          raise StandardError.new("Builder: can't store bit, because its type is not a Number or Boolean, or value doesn't equal 0 nor 1.")
+        end
+
+        bit == 1 || bit == true ? 1 : 0
+      end
+    end
+
+    def check_refs_overflow(size)
+      if size > (4 - @refs.length)
+        raise StandardError.new("Builder: refs overflow. Can't add #{size} refs. Only #{4 - @refs.length} refs left.")
+      end
+    end
+
+    def store_number(value, size)
+      bits = Array.new(size) { |i| ((value >> i) & 1) == 1 ? 1 : 0 }.reverse
+      store_bits(bits)
+      self
+    end
+
+  end
+end