beowulf-ruby-testnet 0.0.1

data/lib/beowulf/type/amount.rb

@@ -0,0 +1,23 @@
+module Beowulf
+  module Type
+    class Amount < Serializer
+      attr_reader :amount, :precision, :asset
+      
+      def initialize(value)
+        super(:amount, value)
+        @amount, @asset = value.strip.split(' ')
+        @precision = 5
+      end
+      
+      def to_bytes
+        asset = @asset.ljust(9, "\x00")
+        amount = (@amount.to_f * 10 ** @precision).round
+        [amount].pack('q') + [@precision].pack('L') + asset
+      end
+      
+      def to_s
+        "#{@amount} #{@asset}"
+      end
+    end
+  end
+end

data/lib/beowulf/type/array.rb

@@ -0,0 +1,17 @@
+module Beowulf
+  module Type
+    class Array < Serializer
+      def initialize(value)
+        super(:array, true)
+      end
+      
+      def to_bytes
+        pakArr(@value)
+      end
+      
+      def to_s
+        @value.to_json
+      end
+    end
+  end
+end

data/lib/beowulf/type/authority.rb

@@ -0,0 +1,48 @@
+require 'json'
+
+module Beowulf
+  module Type
+    class Authority
+      include Utils
+
+      def initialize(options = {})
+        # puts 'Authority.initialize.options', options.to_json
+        @weight_threshold = options[:weight_threshold] || 1
+        @account_auths = options[:account_auths] || []
+        @key_auths = options[:key_auths] || []
+      end
+
+      def to_bytes
+        wt = @weight_threshold.to_i + 0
+        bytes = [wt].pack("I")
+        #uint8_t
+        bytes << pakC(@account_auths.length)
+        if @account_auths.length > 0
+          @account_auths.each do |account|
+            bytes << pakStr(account[0])
+            bytes << pakS(account[1])
+          end
+        end
+        #uint8_t
+        bytes << pakC(@key_auths.length)
+        if @key_auths.length > 0
+          @key_auths.each do |key|
+            bytes << pakPubKey(key[0])
+            bytes << pakS(key[1])
+          end
+        end
+        bytes
+      end
+
+      def to_json(options)
+        JSON.dump ({
+            :weight_threshold => @weight_threshold,
+            :account_auths => @account_auths,
+            :key_auths => @key_auths
+        })
+      end
+
+    end
+  end
+end
+

data/lib/beowulf/type/authority_update.rb

@@ -0,0 +1,50 @@
+require 'json'
+
+module Beowulf
+  module Type
+    class AuthorityUpdate
+      include Utils
+
+      def initialize(options = {})
+        # puts 'AuthorityUpdate.initialize.options', options.to_json
+        @weight_threshold = options[:weight_threshold] || 1
+        @account_auths = options[:account_auths] || []
+        @key_auths = options[:key_auths] || []
+      end
+
+      def to_bytes
+        bytes = unhexlify("01")
+        wt = @weight_threshold.to_i + 0
+        bytes << [wt].pack("I")
+        #uint8_t
+        bytes << pakC(@account_auths.length)
+        if @account_auths.length > 0
+          @account_auths.each do |account|
+            bytes << pakStr(account[0])
+            bytes << pakS(account[1])
+          end
+        end
+        #uint8_t
+        bytes << pakC(@key_auths.length)
+        if @key_auths.length > 0
+          @key_auths.each do |key|
+            bytes << pakPubKey(key[0])
+            bytes << pakS(key[1])
+          end
+        end
+        bytes
+      end
+
+      def to_json(options)
+        JSON.dump ({
+            :weight_threshold => @weight_threshold,
+            :account_auths => @account_auths,
+            :key_auths => @key_auths
+        })
+      end
+
+    end
+  end
+end
+
+

data/lib/beowulf/type/future.rb

@@ -0,0 +1,16 @@
+module Beowulf
+  module Type
+    class Future < Serializer
+      def initialize(value)
+        super(:future, true)
+      end
+      
+      def to_bytes
+        [1].pack('U')
+      end
+      
+      def to_s
+      end
+    end
+  end
+end

data/lib/beowulf/type/hash.rb

@@ -0,0 +1,17 @@
+module Beowulf
+  module Type
+    class Hash < Serializer
+      def initialize(value)
+        super(:hash, true)
+      end
+      
+      def to_bytes
+        pakHash(@value)
+      end
+      
+      def to_s
+        @value.to_json
+      end
+    end
+  end
+end

data/lib/beowulf/type/permission.rb

@@ -0,0 +1,17 @@
+module Beowulf
+  module Type
+    class Permission < Serializer
+      def initialize(value)
+        super(:permission, value)
+      end
+
+      def to_bytes
+        pakHash(@value)
+      end
+
+      def to_s
+        @value.to_json
+      end
+    end
+  end
+end

data/lib/beowulf/type/point_in_time.rb

@@ -0,0 +1,17 @@
+module Beowulf
+  module Type
+    class PointInTime < Serializer
+      def initialize(value)
+        super(:point_in_time, value)
+      end
+      
+      def to_bytes
+        [Time.parse(@value + 'Z').to_i].pack('I')
+      end
+      
+      def to_s
+        @value
+      end
+    end
+  end
+end

data/lib/beowulf/type/public_key.rb

@@ -0,0 +1,18 @@
+module Beowulf
+  module Type
+    class PublicKey < Serializer
+      def initialize(value)
+        super(:public_key, value)
+        raise NotImplementedError, 'stub'
+      end
+
+      def to_bytes
+        pakPubKey(@value)
+      end
+
+      def to_s
+        @value
+      end
+    end
+  end
+end

data/lib/beowulf/type/serializer.rb

@@ -0,0 +1,12 @@
+module Beowulf
+  module Type
+    class Serializer
+      include Beowulf::Utils
+      
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+    end
+  end
+end

data/lib/beowulf/type/u_int16.rb

@@ -0,0 +1,17 @@
+module Beowulf
+  module Type
+    class Uint16 < Serializer
+      def initialize(value)
+        super(:u_int_16, value.to_i)
+      end
+
+      def to_bytes
+        [@value].pack('S')
+      end
+
+      def to_s
+        @value.to_s
+      end
+    end
+  end
+end

data/lib/beowulf/type/u_int32.rb

@@ -0,0 +1,17 @@
+module Beowulf
+  module Type
+    class Uint32 < Serializer
+      def initialize(value)
+        super(:u_int_32, value.to_i)
+      end
+
+      def to_bytes
+        [@value].pack('L')
+      end
+
+      def to_s
+        @value.to_s
+      end
+    end
+  end
+end

data/lib/beowulf/utils.rb

@@ -0,0 +1,221 @@
+require 'base58'
+
+module Beowulf
+  module Utils
+    def extract_signatures(options)
+      return [] unless defined? options[:params].map
+
+      params = options[:params]
+
+      signatures = params.map do |param|
+        next unless defined? param.map
+
+        param.map do |tx|
+          tx[:signatures] rescue nil
+        end
+      end.flatten.compact
+
+      expirations = params.map do |param|
+        next unless defined? param.map
+
+        param.map do |tx|
+          Time.parse(tx[:expiration] + 'Z') rescue nil
+        end
+      end.flatten.compact
+
+      [signatures, expirations.min]
+    end
+
+    def send_log(level, obj, prefix = nil)
+      log_message = case obj
+                    when String
+                      log_message = if !!prefix
+                                      "#{prefix} :: #{obj}"
+                                    else
+                                      obj
+                                    end
+
+                      if !!@logger
+                        @logger.send level, log_message
+                      else
+                        puts "#{level}: #{log_message}"
+                      end
+                    else
+                      if defined? @logger.ap
+                        if !!prefix
+                          @logger.ap log_level: level, prefix => obj
+                        else
+                          @logger.ap obj, level
+                        end
+                      else
+                        if !!prefix
+                          @logger.send level, ({prefix => obj}).inspect
+                        else
+                          @logger.send level, obj.inspect
+                        end
+                      end
+                    end
+
+      nil
+    end
+
+    def error(obj, prefix = nil)
+      send_log(:error, obj, prefix)
+    end
+
+    def warning(obj, prefix = nil, log_debug_node = false)
+      debug("Current node: #{@url}", prefix) if !!log_debug_node && @url
+
+      send_log(:warn, obj, prefix)
+    end
+
+    def debug(obj, prefix = nil)
+      if %w(DEBUG TRACE).include? ENV['LOG']
+        send_log(:debug, obj, prefix)
+      end
+    end
+
+    def hexlify(s)
+      a = []
+      if s.respond_to? :each_byte
+        s.each_byte { |b| a << sprintf('%02X', b) }
+      else
+        s.each { |b| a << sprintf('%02X', b) }
+      end
+      a.join.downcase
+    end
+
+    def unhexlify(s)
+      s.split.pack('H*')
+    end
+
+    def varint(n)
+      data = []
+      while n >= 0x80
+        data += [(n & 0x7f) | 0x80]
+
+        n >>= 7
+      end
+
+      data += [n]
+
+      data.pack('C*')
+    end
+
+    def pakStr(s)
+      s = s.dup.force_encoding('BINARY')
+      bytes = []
+      bytes << varint(s.size)
+      bytes << s
+
+      bytes.join
+    end
+
+    def pakArr(a)
+      varint(a.size) + a.map do |v|
+        case v
+        when Symbol then pakStr(v.to_s)
+        when String then pakStr(v)
+        when Integer then paks(v)
+        when TrueClass then pakC(1)
+        when FalseClass then pakC(0)
+        when ::Array then pakArr(v)
+        when ::Hash then pakHash(v)
+        when NilClass then next
+        else
+          raise OperationError, "Unsupported type: #{v.class}"
+        end
+      end.join
+    end
+
+    def pakHash(h)
+      varint(h.size) + h.map do |k, v|
+        pakStr(k.to_s) + case v
+                         when Symbol then pakStr(v.to_s)
+                         when String then pakStr(v)
+                         when Integer then paks(v)
+                         when TrueClass then pakC(1)
+                         when FalseClass then pakC(0)
+                         when ::Array then pakArr(v)
+                         when ::Hash then pakHash(v)
+                         when NilClass then next
+                         else
+                           raise OperationError, "Unsupported type: #{v.class}"
+                         end
+      end.join
+    end
+
+    #uint8_t
+    def pakC(i)
+      [i].pack('C')
+    end
+
+    #int8_t
+    def pakc(i)
+      [i].pack('c')
+    end
+
+    #int16_t
+    def paks(i)
+      [i].pack('s')
+    end
+
+    #uint16_t
+    def pakS(i)
+      [i].pack('S')
+    end
+
+    #uint32_t
+    def pakI(i)
+      [i].pack('I')
+    end
+
+    #int64_t
+    def pakL!(i)
+      [i].pack('L!')
+    end
+
+    #uint64_t
+    def pakQ(i)
+      [i].pack('Q')
+    end
+
+    #int64_t
+    def pakq(i)
+      [i].pack('q')
+    end
+
+    def pakPubKey(s)
+      # Get substring past index three through end of string.
+      pkn1 = s[3..-1]
+      # puts 'pkn1', pkn1
+
+      #b58.length=37
+      b58 = Base58.base58_to_binary(pkn1, :bitcoin)
+      # puts 'b58.length', b58.length
+      # puts 'b58', hexlify(b58)
+
+      # Get checksum 4-bytes end.
+      lb58 = b58.length-4
+      chs = b58[lb58..-1]
+
+      # Get raw PublicKey = b58 cut 4-bytes checksum.
+      # pkn2.length=33
+      hb58 = lb58-1
+      pkn2 = b58[0..hb58]
+
+      # Validate PublicKey again.
+      checksum = OpenSSL::Digest::RIPEMD160.digest(pkn2)
+      # take 4 bytes.
+      nchs = checksum[0..3]
+      achs = hexlify(chs)
+      bnchs = hexlify(nchs)
+      if !(achs.eql? bnchs)
+        puts achs, bnchs
+        puts 'Public key is incorrect'
+      end
+      pkn2
+    end
+
+  end
+end