ton-sdk-ruby 0.0.1

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

@@ -0,0 +1,335 @@
+module TonSdkRuby
+
+  class Slice
+    def initialize(bits, refs)
+      @bits = bits
+      @refs = refs
+    end
+
+    def bits
+      Array.new(@bits)
+    end
+
+    def refs
+      Array.new(@refs)
+    end
+
+    def skip(size)
+      skip_bits(size)
+    end
+
+    def skip_bits(size)
+      if @bits.length < size
+        raise 'Slice: bits overflow.'
+      end
+
+      @bits.shift(size)
+      self
+    end
+
+    def skip_refs(size)
+      if @refs.length < size
+        raise 'Slice: refs overflow.'
+      end
+
+      @refs.shift(size)
+      self
+    end
+
+    def skip_dict
+      is_empty = load_bit == 0
+      return skip_refs(1) unless is_empty
+
+      self
+    end
+
+    def load_ref
+      raise 'Slice: refs overflow.' if @refs.empty?
+
+      @refs.shift
+    end
+
+    def preload_ref
+      raise 'Slice: refs overflow.' if @refs.empty?
+
+      @refs[0]
+    end
+
+    def load_maybe_ref
+      load_bit == 1 ? load_ref : nil
+    end
+
+    def preload_maybe_ref
+      preload_bit == 1 ? preload_ref : nil
+    end
+
+    def load_bit
+      raise 'Slice: bits overflow.' if @bits.empty?
+
+      @bits.shift
+    end
+
+    def preload_bit
+      raise 'Slice: bits overflow.' if @bits.empty?
+
+      @bits[0]
+    end
+
+    def preload_bit
+      raise 'Slice: bits overflow.' if @bits.empty?
+
+      @bits[0]
+    end
+
+    def load_bits(size)
+      raise 'Slice: bits overflow.' if size < 0 || @bits.length < size
+
+      @bits.shift(size)
+    end
+
+    def preload_bits(size)
+      raise 'Slice: bits overflow.' if size < 0 || @bits.length < size
+
+      @bits[0, size]
+    end
+
+    def load_int(size)
+      bits = load_bits(size)
+      bits_to_int_uint(bits, { type: :int })
+    end
+
+    def preload_int(size)
+      bits = preload_bits(size)
+      bits_to_int_uint(bits, { type: :int })
+    end
+
+    def load_big_int(size)
+      bits = load_bits(size)
+      bits_to_big_int(bits)[:value]
+    end
+
+    def preload_big_int(size)
+      bits = preload_bits(size)
+      bits_to_big_int(bits)[:value]
+    end
+
+    def load_uint(size)
+      bits = load_bits(size)
+
+      bits_to_int_uint(bits, { type: :uint })
+    end
+
+    def preload_uint(size)
+      bits = preload_bits(size)
+      bits_to_int_uint(bits, { type: :uint })
+    end
+
+    def load_big_uint(size)
+      bits = load_bits(size)
+      bits_to_big_uint(bits)[:value]
+    end
+
+    def preload_big_uint(size)
+      bits = preload_bits(size)
+      bits_to_big_uint(bits)[:value]
+    end
+
+    def load_var_int(length)
+      size = Math.log2(length).ceil
+
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+
+      raise 'Slice: can\'t perform loadVarInt – not enough bits' if @bits.length < size_bits + size
+
+      skip(size)
+      load_int(size_bits)
+    end
+
+    def preload_var_int(length)
+      size = Math.log2(length).ceil
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+      bits = preload_bits(size + size_bits)[size..-1]
+
+      bits_to_int_uint(bits, { type: :int })
+    end
+
+    def load_var_big_int(length)
+      size = Math.log2(length).ceil
+
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+
+      raise 'Slice: can\'t perform loadVarBigInt – not enough bits' if @bits.length < size_bits + size
+
+      bits = load_bits(size_bits)
+      bits_to_big_int(bits)[:value]
+    end
+
+    def preload_var_big_int(length)
+      size = Math.log2(length).ceil
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+      bits = preload_bits(size + size_bits)[size..-1]
+      bits_to_big_int(bits)[:value]
+    end
+
+    def load_var_uint(length)
+      size = Math.log2(length).ceil
+
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+
+      raise 'Slice: can\'t perform loadVarUint – not enough bits' if @bits.length < size_bits + size
+
+      skip(size)
+      load_uint(size_bits)
+    end
+
+    def preload_var_uint(length)
+      size = Math.log2(length).ceil
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+      bits = preload_bits(size + size_bits)[size..-1]
+
+      bits_to_int_uint(bits, { type: :uint })
+    end
+
+    def load_var_big_uint(length)
+      size = Math.log2(length).ceil
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+
+      raise 'Slice: can\'t perform loadVarBigUint – not enough bits' if @bits.length < size_bits + size
+
+      bits = skip(size).load_bits(size_bits)
+      bits_to_big_uint(bits)[:value]
+    end
+
+    def preload_var_big_uint(length)
+      size = Math.log2(length).ceil
+      size_bytes = preload_uint(size)
+      size_bits = size_bytes * 8
+      bits = preload_bits(size + size_bits)[size..-1]
+      bits_to_big_uint(bits)[:value]
+    end
+
+    def load_bytes(size)
+      bits = load_bits(size * 8)
+      bits_to_bytes(bits)
+    end
+
+    def preload_bytes(size)
+      bits = preload_bits(size * 8)
+      bits_to_bytes(bits)
+    end
+
+    def load_string(size = nil)
+      bytes = size.nil? ? load_bytes(@bits.length / 8) : load_bytes(size)
+      bytes_to_string(bytes)
+    end
+
+    def preload_string(size = nil)
+      bytes = size.nil? ? preload_bytes(@bits.length / 8) : preload_bytes(size)
+      bytes_to_string(bytes)
+    end
+
+    def load_address
+      flag_address_no = [0, 0]
+      flag_address = [1, 0]
+      flag = preload_bits(2)
+
+      if flag == flag_address_no
+        skip(2)
+        Address::NONE
+      elsif flag == flag_address
+        # 2 bits flag, 1 bit anycast, 8 bits workchain, 256 bits address hash
+        size = 2 + 1 + 8 + 256
+        # Slice 2 because we don't need flag bits
+        bits = load_bits(size)[2..-1]
+
+        # Anycast is currently unused
+        _anycast = bits.shift
+
+        workchain = bits_to_int_uint(bits.shift(8), type: 'int')
+        hash = bits_to_hex(bits.shift(256))
+        raw = "#{workchain}:#{hash}"
+
+        Address.new(raw)
+      else
+        raise 'Slice: bad address flag bits.'
+      end
+    end
+
+    def preload_address
+      flag_address_no = [0, 0]
+      flag_address = [1, 0]
+      flag = preload_bits(2)
+
+      if flag == flag_address_no
+        Address::NONE
+      elsif flag == flag_address
+        # 2 bits flag, 1 bit anycast, 8 bits workchain, 256 bits address hash
+        size = 2 + 1 + 8 + 256
+        bits = preload_bits(size)[2..-1]
+        # Splice 2 because we don't need flag bits
+
+        # Anycast is currently unused
+        _anycast = bits.shift
+
+        workchain = bits_to_int_uint(bits.shift(8), { type: 'int' })
+        hash = bits_to_hex(bits.shift(256))
+        raw = "#{workchain}:#{hash}"
+
+        Address.new(raw)
+      else
+        raise 'Slice: bad address flag bits.'
+      end
+    end
+
+    def load_coins(decimals = 9)
+      coins = load_var_big_uint(16)
+      Coins.new(coins, is_nano: true, decimals: decimals)
+    end
+
+    def preload_coins(decimals = 9)
+      coins = preload_var_big_uint(16)
+      Coins.new(coins, is_nano: true, decimals: decimals)
+    end
+
+    def load_dict(key_size, options = {})
+      dict_constructor = load_bit
+      is_empty = dict_constructor.zero?
+
+      if !is_empty
+        HashmapE.parse(
+          key_size,
+          Slice.new([dict_constructor], [load_ref]),
+          options
+        )
+      else
+        HashmapE.new(key_size, options)
+      end
+    end
+
+    def preload_dict(key_size, options = {})
+      dict_constructor = preload_bit
+      is_empty = dict_constructor.zero?
+
+      if !is_empty
+        HashmapE.parse(
+          key_size,
+          Slice.new([dict_constructor], [preload_ref]),
+          options
+        )
+      else
+        HashmapE.new(key_size, options)
+      end
+    end
+
+    def self.parse(cell)
+      Slice.new(cell.bits.dup, cell.refs.dup)
+    end
+  end
+end

data/lib/ton-sdk-ruby/johnny_mnemonic/ton_mnemonic.rb

@@ -0,0 +1,144 @@
+require 'securerandom'
+require 'digest'
+require 'openssl'
+require 'openssl/pkcs5'
+require "ed25519"
+
+module TonSdkRuby
+  class TonMnemonic
+    include TonSdkRuby
+
+    TON_PBKDF_ITERATIONS = 100_000
+    TON_KEYS_SALT = 'TON default seed'
+    TON_SEED_SALT = 'TON seed version'
+    TON_PASSWORD_SALT = 'TON fast seed version'
+
+    attr_accessor :seed, :mnemonic_array, :keys, :password, :words_count
+
+    def initialize(password = nil, words_count = 24)
+      @words_count = words_count
+      @password = password
+      @mnemonic_array = generate_seed(words_count, password)
+      @seed = mnemonic_array.join(' ')
+      @keys = mnemonic_to_private_key(mnemonic_array, password)
+    end
+
+    def self.parse(mnemonic_string, password = nil)
+      mnemonic = new
+      mnemonic_string.gsub!(/\s+/, ' ')
+      mnemonic.mnemonic_array = mnemonic_string.split(' ')
+      mnemonic.words_count = mnemonic.mnemonic_array.size
+      mnemonic.password = password
+      mnemonic.seed = mnemonic.mnemonic_array.join(' ')
+      mnemonic.keys = mnemonic.mnemonic_to_private_key(mnemonic.mnemonic_array, password)
+      mnemonic
+    end
+
+    def get_secure_random_number(min, max)
+      range = max - min
+      bits_needed = Math.log2(range).ceil
+      raise 'Range is too large' if bits_needed > 53
+      bytes_needed = (bits_needed / 8.0).ceil
+      mask = (2 ** bits_needed) - 1
+
+      loop do
+        res = SecureRandom.random_bytes(bytes_needed)
+        power = (bytes_needed - 1) * 8
+        number_value = 0
+        res.each_byte do |byte|
+          number_value += byte.ord * (2 ** power)
+          power -= 8
+        end
+        number_value = number_value & mask # Truncate
+        return min + number_value if number_value < range
+      end
+    end
+
+    def generate_seed(words_count = 24, password = nil)
+      mnemonic_array = []
+      while true
+        # Regenerate new mnemonics
+        mnemonic_array = generate_words_ton(words_count)
+        # # Check password conformance
+        if password && password.length > 0
+          next unless password_needed?(mnemonic_array)
+        end
+        # Check if basic seed correct
+        unless basic_seed?(mnemonic_to_entropy(mnemonic_array, password))
+          next
+        end
+        break
+      end
+      mnemonic_array
+    end
+
+    def mnemonic_to_entropy(mnemonic_array, password = nil)
+      mnemonic_string = mnemonic_array.join(' ')
+      password_string = password || ''
+      # OpenSSL::HMAC.digest(digest, key, data)
+      hmac = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), mnemonic_string, password_string)
+      entropy = bytes_to_hex(hmac.unpack('C*'))
+
+      entropy
+    end
+
+    def generate_words_ton(length)
+      mnemonic_array = []
+      current_file_path = File.expand_path(File.dirname(__FILE__))
+      bip0039en = JSON.parse(File.read("#{current_file_path}/words/english.json"))
+      length.times do
+        index = get_secure_random_number(0, length)
+        mnemonic_array.push(bip0039en[index])
+      end
+
+      mnemonic_array
+    end
+
+    def mnemonic_to_private_key(mnemonic_array, password = nil)
+      mnemonic_array = normalize_mnemonic(mnemonic_array)
+      seed = mnemonic_to_seed(mnemonic_array, TON_KEYS_SALT, password)
+      key_pair = Ed25519::SigningKey.new(seed[0, 32])
+      {
+        public: key_pair.verify_key.to_bytes.unpack1('H*'),
+        secret: key_pair.to_bytes.unpack1('H*')
+      }
+    end
+
+    def mnemonic_to_seed(mnemonic_array, salt, password)
+      entropy_hex = mnemonic_to_entropy(mnemonic_array, password)
+      entropy = bytes_to_data_string(hex_to_bytes(entropy_hex))
+      hash = OpenSSL::Digest::SHA512.new
+      OpenSSL::KDF.pbkdf2_hmac(entropy, salt: salt, iterations: TON_PBKDF_ITERATIONS, length: 64, hash: hash)
+    end
+
+    private
+    def basic_seed?(entropy_hex)
+      # pbkdf2_hmac(pass, salt, iter, keylen, digest)
+      entropy = bytes_to_data_string(hex_to_bytes(entropy_hex))
+      iter = [1, TON_PBKDF_ITERATIONS / 256].max
+      hash = OpenSSL::Digest::SHA512.new
+      key = OpenSSL::KDF.pbkdf2_hmac(entropy, salt: TON_SEED_SALT, iterations: iter, length: 64, hash: hash)
+
+      key.bytes.first == 0
+    end
+
+    def password_seed?(entropy_hex)
+      # pbkdf2_hmac(pass, salt, iter, keylen, digest)
+      entropy = bytes_to_data_string(hex_to_bytes(entropy_hex))
+      iter = 1
+      hash = OpenSSL::Digest::SHA512.new
+      key = OpenSSL::KDF.pbkdf2_hmac(entropy, salt: TON_PASSWORD_SALT, iterations: iter, length: 64, hash: hash)
+
+      key.bytes.first == 1
+    end
+
+    def password_needed?(mnemonic_array)
+      passless_entropy = mnemonic_to_entropy(mnemonic_array)
+      password_seed?(passless_entropy) && !basic_seed?(passless_entropy)
+    end
+
+    def normalize_mnemonic(words)
+      words.map { |v| v.downcase.strip }
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require_relative './utils'
+require 'securerandom'
+require 'json'
+require 'openssl'
+require 'openssl/pkcs5'
+
+module TonSdkRuby
+  
+  private def derive_checksum_bits_bip39(entropy_bytes)
+    cs = (entropy_bytes.size * 8) / 32
+    hex = sha256(entropy_bytes)
+    bits = hex_to_bits(hex)
+    
+
+    bits.slice(0, cs)
+  end
+
+  def generate_words_bip39(length)
+    current_file_path = File.expand_path(File.dirname(__FILE__))
+    bip0039en = JSON.parse(File.read("#{current_file_path}/words/english.json"))
+    entropy = SecureRandom.random_bytes(bytes_needed_for_words(length)).unpack('C*')
+    checksum_bits = derive_checksum_bits(entropy)
+    entropy_bits = bytes_to_bits(entropy)
+    full_bits = entropy_bits + checksum_bits
+    chunks = full_bits.join('').scan(/.{1,11}/)
+    words = chunks.map do |chunk|
+      index = chunk.to_i(2)
+      bip0039en[index]
+    end
+
+    words
+  end
+
+  def bytes_needed_for_words_bip39(word_count)
+    full_entropy = word_count * 11
+    checksum = full_entropy % 32
+    initial_entropy = full_entropy - checksum
+    initial_entropy / 8
+  end
+end