ton-sdk-ruby 0.0.1

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

@@ -0,0 +1,188 @@
+require 'bigdecimal'
+
+module TonSdkRuby
+
+  class Coins
+    attr_reader :value, :decimals, :multiplier
+    private :value, :decimals, :multiplier
+
+    def initialize(value, options = {})
+      is_nano = options[:is_nano] || false
+      decimals = options[:decimals] || 9
+
+      value = value.to_s
+      Coins.check_coins_type(value)
+      Coins.check_coins_decimals(decimals)
+
+      decimal = BigDecimal(value)
+
+      if decimal.dp > decimals
+        raise "Invalid Coins value, decimals places \"#{decimal.dp}\" can't be greater than selected \"#{decimals}\""
+      end
+
+      @decimals = decimals
+      @multiplier = (1 * 10) ** @decimals
+      @value = is_nano ? decimal : decimal * @multiplier
+    end
+
+    def self.from_nano(value, decimals = 9)
+      check_coins_type(value)
+      check_coins_decimals(decimals)
+
+      Coins.new(value, is_nano: true, decimals: decimals)
+    end
+
+    def add(coins)
+      Coins.check_coins(coins)
+      Coins.compare_coins_decimals(self, coins)
+
+      @value += coins.value
+
+      self
+    end
+
+    def sub(coins)
+      Coins.check_coins(coins)
+      Coins.compare_coins_decimals(self, coins)
+
+      @value -= coins.value
+
+      self
+    end
+
+    def mul(value)
+      Coins.check_value(value)
+      Coins.check_convertability(value)
+
+      multiplier = value.to_s
+
+      @value *= multiplier.to_i
+
+      self
+    end
+
+    def div(value)
+      Coins.check_value(value)
+      Coins.check_convertibility(value)
+
+      divider = value.to_s
+
+      @value /= divider.to_i
+
+      self
+    end
+
+    def eq(coins)
+      Coins.check_coins(coins)
+      Coins.compare_coins_decimals(self, coins)
+
+      @value == coins.value
+    end
+
+    def gt(coins)
+      Coins.check_coins(coins)
+      Coins.compare_coins_decimals(self, coins)
+
+      @value > coins.value
+    end
+
+    def gte(coins)
+      Coins.check_coins(coins)
+      Coins.compare_coins_decimals(self, coins)
+
+      @value >= coins.value
+    end
+
+    def lt(coins)
+      Coins.check_coins(coins)
+      Coins.compare_coins_decimals(self, coins)
+
+      @value < coins.value
+    end
+
+    def lte(coins)
+      Coins.check_coins(coins)
+      Coins.compare_coins_decimals(self, coins)
+
+      @value <= coins.value
+    end
+
+    def negative?
+      @value.negative?
+    end
+
+    def positive?
+      @value.positive?
+    end
+
+    def zero?
+      @value.zero?
+    end
+
+    def to_s
+      value = (@value / @multiplier.to_f).round(@decimals).to_s
+
+      # Remove all trailing zeroes
+      coins = value.sub(/\.0{#{@decimals}}$/, '').sub(/(\.[0-9]*?[0-9])0+$/, '\1')
+
+      coins
+    end
+
+    def to_nano
+      @value.to_i
+    end
+
+
+    private
+
+    def self.check_coins_type(value)
+      raise 'Invalid Coins value' unless valid?(value) && convertable?(value)
+      raise 'Invalid Coins value' if coins?(value)
+    end
+
+    def self.check_coins_decimals(decimals)
+      raise 'Invalid decimals value, must be 0-18' if decimals < 0 || decimals > 18
+    end
+
+    def self.compare_coins_decimals(a, b)
+      raise "Can't perform mathematical operation of Coins with different decimals" if a.decimals != b.decimals
+    end
+
+    def self.check_value(value)
+      raise 'Invalid value' unless valid?(value)
+    end
+
+    def self.check_coins(value)
+      raise 'Invalid value' unless coins?(value)
+    end
+
+    def self.check_convertability(value)
+      raise 'Invalid value' unless convertable?(value)
+    end
+
+    def self.valid?(value)
+      value.class == String || value.class == Integer
+    end
+
+    def self.coins?(value)
+      value.is_a?(Coins)
+    end
+
+    def self.convertable?(value)
+      begin
+        BigDecimal(value.to_s)
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end
+
+class BigDecimal
+  def dp
+    digits_after_comma = self.to_s("F").split(".").last
+    return 0 if digits_after_comma == '0'
+    digits_after_comma.size
+  end
+end

data/lib/ton-sdk-ruby/utils/bits.rb

@@ -0,0 +1,25 @@
+module TonSdkRuby
+
+  def augment(bits, divider = 8)
+    bits = Array.new(bits)
+    amount = divider - (bits.size % divider)
+    overage = Array.new(amount, 0)
+    overage[0] = 1
+
+    if overage.size != 0 && overage.size != divider
+      return bits.concat(overage)
+    end
+
+    bits
+  end
+
+  def rollback(bits)
+    index = bits.last(7).reverse.index(1)
+
+    if index.nil?
+      raise StandardError.new('Incorrectly augmented bits.')
+    end
+
+    bits[0, bits.length - (index + 1)]
+  end
+end

data/lib/ton-sdk-ruby/utils/checksum.rb

@@ -0,0 +1,46 @@
+module TonSdkRuby
+
+  def crc16(data)
+    poly = 0x1021
+    bytes = data.is_a?(String) ? data.unpack('C*') : Array.new(data)
+    int16 = bytes.reduce(0) do |acc, el|
+      crc = acc ^ (el << 8)
+
+      8.times do
+        crc = (crc & 0x8000) == 0x8000 ? (crc << 1) ^ poly : crc << 1
+      end
+
+      crc
+    end & 0xffff
+
+    [int16].pack("S").unpack1("S")
+  end
+
+  def crc16_bytes_be(data)
+    crc = crc16(data)
+    [crc].pack("S>").bytes
+  end
+
+  def crc32c(data)
+    poly = 0x82f63b78
+    bytes = data.is_a?(String) ? data.unpack('C*') : Array.new(data)
+
+    int32 = bytes.reduce(0 ^ 0xffffffff) do |acc, el|
+      crc = acc ^ el
+
+      8.times do
+        crc = crc & 1 == 1 ? (crc >> 1) ^ poly : crc >> 1
+      end
+
+      crc
+    end ^ 0xffffffff
+
+    [int32].pack("L>").unpack1("L>")
+  end
+
+  def crc32c_bytes_le(data)
+    crc = crc32c(data)
+    [crc].pack("L<").bytes
+  end
+
+end

data/lib/ton-sdk-ruby/utils/hash.rb

@@ -0,0 +1,15 @@
+require 'digest'
+require_relative 'helpers.rb'
+
+module TonSdkRuby
+
+  def sha256(bytes)
+    digest = Digest::SHA256.digest(bytes.pack('C*'))
+    bytes_to_hex(digest)
+  end
+
+  def sha512(bytes)
+    digest = Digest::SHA512.digest(bytes.pack('C*'))
+    bytes_to_hex(digest)
+  end
+end

data/lib/ton-sdk-ruby/utils/helpers.rb

@@ -0,0 +1,161 @@
+require 'base64'
+require 'ed25519'
+require "json"
+require 'net/http'
+require 'uri'
+
+module TonSdkRuby
+
+
+  INT32_MAX = 2147483647
+  INT32_MIN = -2147483648
+
+  def uint_to_hex(uint)
+    hex = sprintf("%#x", uint)
+    hex[-(hex.length / 2 * 2)..-1]
+  end
+
+  def hex_to_bits(hex)
+    result = hex.split('').flat_map do |val|
+      chunk = val.to_i(16)
+                 .to_s(2)
+                 .rjust(4, '0')
+                 .split('')
+                 .map(&:to_i)
+
+      chunk
+    end
+
+    result
+  end
+
+  def bytes_to_uint(bytes)
+    uint = bytes.each_with_index.inject(0) do |acc, (byte, i)|
+      acc *= 256
+      acc += byte
+      acc
+    end
+    uint
+  end
+
+  def bytes_compare(a, b)
+    return false if a.length != b.length
+
+    a.each_with_index.all? { |uint, i| uint == b[i] }
+  end
+
+  def hex_to_bytes(hex)
+    hex.scan(/.{1,2}/).map { |byte| byte.to_i(16) }
+  end
+
+  def bytes_to_bits(data)
+    bytes = data.is_a?(Array) ? data : data.unpack("C*")
+
+    result = bytes.reduce([]) do |acc, uint|
+      chunk = uint.to_s(2)
+                  .rjust(8, '0')
+                  .split('')
+                  .map(&:to_i)
+
+      acc.concat(chunk)
+    end
+    result
+  end
+
+  def bits_to_hex(bits)
+    bitstring = bits.join('')
+    hex = bitstring.scan(/.{1,4}/).map { |el| el.rjust(4, '0').to_i(2).to_s(16) }
+    hex.join('')
+  end
+
+  def bits_to_bytes(bits)
+    return [].pack("C*") if bits.empty?
+
+    hex_to_bytes(bits_to_hex(bits))
+  end
+
+  def bytes_to_hex(bytes)
+    if bytes.is_a?(Array)
+      bytes.pack('C*').unpack('H*').first
+    else
+      bytes.unpack('H*').first
+    end
+  end
+
+  def bytes_to_string(bytes)
+    bytes.pack("C*").force_encoding('utf-8')
+  end
+
+  def bytes_to_data_string(bytes)
+    raise 'Only byte array' unless bytes.is_a?(Array)
+    bytes.pack('C*')
+  end
+
+  def hex_to_data_string(hex)
+    bytes_to_data_string(hex_to_bytes(hex))
+  end
+
+  def string_to_bytes(value)
+    value.bytes
+  end
+
+  def bytes_to_base64(data)
+    bytes = data.is_a?(String) ? data.unpack("C*") : data
+    str = bytes.map(&:chr).join
+
+    Base64.strict_encode64(str)
+  end
+
+  def base64_to_bytes(base64)
+    binary = Base64.strict_decode64(base64)
+    binary.bytes
+  end
+
+  def slice_into_chunks(arr, chunk_size)
+    res = []
+
+    (0...arr.length).step(chunk_size) do |i|
+      chunk = arr[i, chunk_size]
+      res.push(chunk)
+    end
+
+    res
+  end
+
+  def sign_cell(cell, private_key)
+    hash = hex_to_data_string(cell.hash)
+    data_key = hex_to_data_string(private_key)
+    Ed25519::SigningKey.new(data_key).sign(hash)
+  end
+
+  def read_json_from_link(link)
+    uri = URI.parse("#{link}")
+    request = Net::HTTP::Get.new(uri)
+
+    request.content_type = "application/json"
+    req_options = { use_ssl: uri.scheme == "https" }
+    response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+      http.request(request)
+    end
+    JSON.parse(response.body)
+  end
+
+  def read_post_json_from_link(url, body, headers)
+    uri = URI.parse(url)
+    request = Net::HTTP::Post.new(uri)
+    request.content_type = "application/json"
+    headers.each do |name, value|
+      request[name.to_s] = value
+    end
+    request.body = JSON.generate(body)
+    req_options = { use_ssl: uri.scheme == "https" }
+    response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+      http.request(request)
+    end
+    JSON.parse(response.body)
+  end
+
+  def require_type(name, value, type)
+    raise "#{name} must be #{type}" unless value.is_a?(type)
+  end
+end

data/lib/ton-sdk-ruby/utils/numbers.rb

@@ -0,0 +1,42 @@
+module TonSdkRuby
+
+  def bits_to_big_uint(bits)
+    return { value: 0, is_safe: true } if bits.empty?
+
+    value = bits.reverse.each_with_index.inject(0) { |acc, (bit, i)| bit.to_i * (2 ** i) + acc }
+
+    is_safe = value <= Float::MAX.to_i
+
+    {
+      value: value,
+      is_safe: is_safe
+    }
+  end
+
+  def bits_to_big_int(bits)
+    return { value: 0, is_safe: true } if bits.empty?
+
+    uint_result = bits_to_big_uint(bits)
+    uint = uint_result[:value]
+    size = bits.size
+    int = 1 << (size - 1)
+    value = uint >= int ? (uint - (int * 2)) : uint
+    is_safe = value >= Float::MIN.to_i && value <= Float::MAX.to_i
+
+    {
+      value: value,
+      is_safe: is_safe
+    }
+  end
+
+  def bits_to_int_uint(bits, options = { type: 'int' })
+    type = options[:type].to_s || 'uint'
+    result = if type == 'uint'
+               bits_to_big_uint(bits)
+             else
+               bits_to_big_int(bits)
+             end
+
+    result[:value]
+  end
+end

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

@@ -0,0 +1,4 @@
+module TonSdkRuby
+  VERSION = "0.0.1"
+end
+

data/lib/ton-sdk-ruby.rb

@@ -0,0 +1,29 @@
+require_relative './ton-sdk-ruby/version'
+require_relative './ton-sdk-ruby/bit_array/bit_array'
+
+require_relative './ton-sdk-ruby/utils/helpers'
+require_relative './ton-sdk-ruby/utils/bits'
+require_relative './ton-sdk-ruby/utils/checksum'
+require_relative './ton-sdk-ruby/utils/hash'
+require_relative './ton-sdk-ruby/utils/numbers'
+
+require_relative './ton-sdk-ruby/types/Address'
+require_relative './ton-sdk-ruby/types/Block'
+require_relative './ton-sdk-ruby/types/Coins'
+
+require_relative './ton-sdk-ruby/boc/mask'
+require_relative './ton-sdk-ruby/boc/cell'
+require_relative './ton-sdk-ruby/boc/hashmap'
+require_relative './ton-sdk-ruby/boc/slice'
+require_relative './ton-sdk-ruby/boc/builder'
+require_relative './ton-sdk-ruby/boc/serializer'
+
+require_relative './ton-sdk-ruby/johnny_mnemonic/utils'
+require_relative './ton-sdk-ruby/johnny_mnemonic/ton_mnemonic'
+
+require_relative './ton-sdk-ruby/providers/toncenter'
+require_relative './ton-sdk-ruby/providers/provider'
+
+
+module TonSdkRuby
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: ton-sdk-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- nerzh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem Ton SDK Ruby for all TVM ruby projects
+email:
+- emptystamp@gmail.com
+executables:
+- ton-sdk-ruby
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ton-sdk-ruby
+- lib/ton-sdk-ruby.rb
+- lib/ton-sdk-ruby/bit_array/bit_array.rb
+- lib/ton-sdk-ruby/boc/builder.rb
+- lib/ton-sdk-ruby/boc/cell.rb
+- lib/ton-sdk-ruby/boc/hashmap.rb
+- lib/ton-sdk-ruby/boc/mask.rb
+- lib/ton-sdk-ruby/boc/serializer.rb
+- lib/ton-sdk-ruby/boc/slice.rb
+- lib/ton-sdk-ruby/johnny_mnemonic/ton_mnemonic.rb
+- lib/ton-sdk-ruby/johnny_mnemonic/utils.rb
+- lib/ton-sdk-ruby/johnny_mnemonic/words/english.json
+- lib/ton-sdk-ruby/providers/provider.rb
+- lib/ton-sdk-ruby/providers/toncenter.rb
+- lib/ton-sdk-ruby/types/address.rb
+- lib/ton-sdk-ruby/types/block.rb
+- lib/ton-sdk-ruby/types/coins.rb
+- lib/ton-sdk-ruby/utils/bits.rb
+- lib/ton-sdk-ruby/utils/checksum.rb
+- lib/ton-sdk-ruby/utils/hash.rb
+- lib/ton-sdk-ruby/utils/helpers.rb
+- lib/ton-sdk-ruby/utils/numbers.rb
+- lib/ton-sdk-ruby/version.rb
+homepage: https://github.com/nerzh/ton-sdk-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: This is gem ton-sdk-ruby
+test_files: []