platon 0.2.7

data/lib/platon/contract_event.rb

@@ -0,0 +1,24 @@
+module Platon
+  class ContractEvent
+
+    attr_accessor :name, :signature, :input_types, :inputs, :event_string, :address, :client
+
+    def initialize(data)
+      @name = data["name"]
+      @input_types = data["inputs"].collect {|x| x["type"]}
+      @inputs = data["inputs"].collect {|x| x["name"]}
+      @event_string = "#{@name}(#{@input_types.join(",")})"
+      @signature = Digest::SHA3.hexdigest(@event_string, 256)
+    end
+
+    def set_address(address)
+      @address = address
+    end
+
+    def set_client(client)
+      @client = client
+    end
+
+  end
+end
+

data/lib/platon/contract_initializer.rb

@@ -0,0 +1,54 @@
+module Platon
+
+  class ContractInitializer
+
+    attr_accessor :abi, :binary, :name, :libraries, :needs_linking, :project_initializer, :contract
+
+    def initialize(contract_name, contract, project_initializer)
+      @abi = JSON.parse(contract["abi"]) unless contract.nil?
+      @binary = contract["bin"] unless contract.nil?
+      @name = contract_name
+      @project_initializer = project_initializer
+      matchdata = @binary.scan(/_+[a-zA-Z]+_+/).uniq
+      @needs_linking = matchdata.present?
+      if @needs_linking
+        @libraries = matchdata.collect do |libname|
+          {name: libname.gsub(/_+/,''), sigil: libname}
+        end
+      end
+    end
+
+    def link_libraries
+      if @needs_linking
+        @libraries.each do |library|
+          name = library[:name]
+          if @project_initializer.libraries[name].nil?
+            ENV['ETHEREUM_DEPLOYER_WAIT_TIME'] ||= "120"
+            wait_time = ENV['ETHEREUM_DEPLOYER_WAIT_TIME'].to_i
+            library_instance = library[:name].constantize.new
+            puts "Deploying library #{name}"
+            library_instance.deploy_and_wait(wait_time)
+            puts "Library deployed at #{library_instance.address}"
+            @project_initializer.libraries[name] = library_instance.address
+            @binary.gsub!(library[:sigil], library_instance.address.gsub(/^0x/,''))
+          else
+            address = @project_initializer.libraries[name]
+            @binary.gsub!(library[:sigil], address.gsub(/^0x/,''))
+          end
+        end
+      end
+    end
+
+    def build(connection)
+      @contract = Platon::Contract.new(@name, @binary, @abi, client)
+      @contract.build(connection)
+    end
+
+    def generate_javascripts(path)
+      data = {name: @name, abi: @abi, binary: @binary}
+      File.open(File.join(path, "#{@name}.json"), 'w') {|f| f.puts data.to_json}
+    end
+
+  end
+
+end

data/lib/platon/decoder.rb

@@ -0,0 +1,99 @@
+module Platon
+  class Decoder
+
+    def decode(type, value, start = 0)
+      is_array, arity, array_subtype = Abi::parse_array_type(type)
+      if is_array && arity
+        decode_static_array(arity, array_subtype, value, start)
+      elsif is_array
+        decode_dynamic_array(array_subtype, value, start)
+      else
+        value = value.gsub(/^0x/,'')
+        core, subtype = Abi::parse_type(type)
+        method_name = "decode_#{core}".to_sym
+        self.send(method_name, value, subtype, start)
+      end
+    end
+
+    def decode_static_array(arity, array_subtype, value, start)
+      (0..arity-1).map { |i| decode(array_subtype, value, start + i * 64) }
+    end
+
+    def decode_dynamic_array(array_subtype, value, start)
+      location = decode_uint(value[start..(start+63)]) * 2
+      size = decode_uint(value[location..location+63])
+      (0..size-1).map { |i| decode(array_subtype, value, location + (i+1) * 64) }
+    end
+
+    def decode_fixed(value, subtype = "128x128", start = 0)
+      decode_int(trim(value, start, fixed_bitsize(subtype))).to_f / 2**exponent(subtype)
+    end
+
+    def decode_uint(value, subtype = "256", start = 0)
+      trim(value, start, bitsize(subtype)).hex
+    end
+
+    def decode_int(value, subtype = "256", start = 0)
+      raise ArgumentError if value.nil?
+      size = bitsize(subtype)
+      value = trim(value, start, size)
+      (value[0..1] == "ff") ? (value.hex - (2 ** size)) : value.hex
+    end
+
+    def decode_bool(value, _, start)
+      value = trim(value, start, 4)
+      return true if value == "1"
+      return false if value == "0"
+      raise ArgumentError
+    end
+
+    def decode_address(value, _ = nil, start)
+      raise ArgumentError if value.size-start < 64
+      value[start+24..start+63]
+    end
+
+    def decode_bytes(value, subtype, start)
+      subtype.present? ? decode_static_bytes(value, subtype, start) : decode_dynamic_bytes(value, start)
+    end
+
+    def decode_static_bytes(value, subtype = nil, start = 0)
+      trim(value, start, subtype.to_i*8).scan(/.{2}/).collect {|x| x.hex}.pack('C*').strip
+    end
+
+    def decode_dynamic_bytes(value, start = 0)
+      location = decode_uint(value[start..(start+63)]) * 2
+      size = decode_uint(value[location..location+63]) * 2
+      value[location+64..location+63+size].scan(/.{2}/).collect {|x| x.hex}.pack('C*')
+    end
+
+    def decode_string(value, _ = nil, start = 0)
+      decode_dynamic_bytes(value, start).force_encoding('utf-8')
+    end
+
+    def decode_arguments(arguments, data)
+      data = data.gsub(/^0x/,'')
+      types = arguments.map { |o| o.type }
+      types.each.with_index.map { |t , i| decode(t, data, i*64) }
+    end
+
+    private 
+      def trim(value, start, bitsize = 256)
+        value[start+63-(bitsize/4-1)..start+63]
+      end
+
+      def bitsize(subtype, default = 256)
+        subtype.present? ? subtype.to_i : default
+      end
+
+      def fixed_bitsize(subtype = nil)
+        subtype ||= "128x128"
+        _, x, n = /(\d+)x(\d+)/.match(subtype).to_a
+        x.to_i + n.to_i
+      end
+
+      def exponent(subtype, default = 128)
+        subtype.nil? ? default : /(\d+)x(\d+)/.match(subtype)[2].to_i
+      end
+
+  end
+end

data/lib/platon/deployment.rb

@@ -0,0 +1,49 @@
+module Platon
+
+  class Deployment
+
+    DEFAULT_TIMEOUT = 300.seconds
+    DEFAULT_STEP = 5.seconds
+
+    attr_accessor :id, :contract_address, :connection, :deployed, :mined
+    attr_reader :valid_deployment
+
+    def initialize(txid, connection)
+      @id = txid
+      @connection = connection
+      @deployed = false
+      @contract_address = nil
+      @valid_deployment = false
+    end
+
+    def mined?
+      return true if @mined
+      @mined = @connection.platon_get_transaction_by_hash(@id)["result"]["blockNumber"].present?
+      @mined ||= false
+    end
+
+    def check_deployed
+      return false unless @id
+      contract_receipt = @connection.platon_get_transaction_receipt(@id)
+      result = contract_receipt["result"]
+      has_contract_address = result && result["contractAddress"]
+      @contract_address ||= result["contractAddress"] if has_contract_address
+      has_contract_address && result["blockNumber"]
+    end
+
+    def deployed?
+      @valid_deployment ||= check_deployed
+    end
+
+    def wait_for_deployment(timeout: DEFAULT_TIMEOUT, step: DEFAULT_STEP)
+      start_time = Time.now
+      loop do
+        raise "Transaction #{@id} timed out." if ((Time.now - start_time) > timeout) 
+        yield if block_given?
+        return true if deployed?
+        sleep step
+      end
+    end
+
+  end
+end

data/lib/platon/encoder.rb

@@ -0,0 +1,120 @@
+module Platon
+
+  class Encoder
+
+    def encode(type, value)
+      is_array, arity, array_subtype = Abi::parse_array_type(type)
+      if is_array && arity
+        encode_static_array(arity, array_subtype, value)
+      elsif is_array
+        encode_dynamic_array(array_subtype, value)
+      else
+        core, subtype = Abi::parse_type(type)
+        method_name = "encode_#{core}".to_sym
+        self.send(method_name, value, subtype)
+      end
+    end
+
+    def encode_static_array(arity, array_subtype, array)
+      raise "Wrong number of arguments" if arity != array.size
+      array.inject("") { |a, e| a << encode(array_subtype, e) }
+    end
+
+    def encode_dynamic_array(array_subtype, array)
+      location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+      size = encode_uint(array.size)
+      data = array.inject("") { |a, e| a << encode(array_subtype, e) }
+      [location, size + data]
+    end
+
+    def encode_int(value, _ = nil)
+      to_twos_complement(value).to_s(16).rjust(64, '0')
+    end
+
+    def encode_uint(value, _ = nil)
+      raise ArgumentError if value < 0
+      encode_int(value)
+    end
+
+    def encode_bool(value, _)
+      (value ? "1" : "0").rjust(64, '0')
+    end
+
+    def encode_fixed(value, subtype)
+      n = subtype.nil? ? 128 : /(\d+)x(\d+)/.match(subtype)[2].to_i
+      do_encode_fixed(value, n)
+    end
+
+    def do_encode_fixed(value, n)
+      encode_uint((value * 2**n).to_i)
+    end
+
+    def encode_ufixed(_value, _)
+      raise NotImplementedError
+    end
+
+    def encode_bytes(value, subtype)
+      subtype.nil? ? encode_dynamic_bytes(value) : encode_static_bytes(value)
+    end
+
+    def encode_static_bytes(value)
+      value.bytes.map {|x| x.to_s(16).rjust(2, '0')}.join("").ljust(64, '0')
+    end
+
+    def encode_dynamic_bytes(value)
+      location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+      size = encode_uint(value.size)
+      content = encode_static_bytes(value)
+      [location, size + content]
+    end
+
+    def encode_string(value, _)
+      location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+      size = encode_uint(value.bytes.size)
+      content = value.bytes.map {|x| x.to_s(16).rjust(2, '0')}.join("").ljust(64, '0')
+      [location, size + content]
+    end
+
+    def encode_address(value, _)
+      # puts "value: #{value}"  
+      value = Utils.decode_bech32_address(value) if Utils.is_bech32_address?(value)
+      value = "0" * 24 + value.gsub(/^0x/,'')
+      raise ArgumentError if value.size != 64
+      value
+    end
+
+    def ensure_prefix(value)
+      value.start_with?("0x") ? value : ("0x" + value)
+    end
+
+    def encode_arguments(inputs, args)
+      raise "Wrong number of arguments" if inputs.length != args.length
+      @head = ""
+      @tail = ""
+      @inputs = inputs
+      inputs.each.with_index do |input, index|
+        encoded = encode(input.type, args[index])
+        if encoded.is_a? Array
+          @head << encoded[0]
+          @tail << encoded[1]
+        else
+          @head << encoded
+        end
+      end
+      @head + @tail
+    end
+
+    private
+      def to_twos_complement(number)
+        (number & ((1 << 256) - 1))
+      end
+
+      def size_of_inputs(inputs)
+        inputs.map do |input|
+          _, arity, _ = Abi::parse_array_type(input.type)
+          arity.nil? ? 32 : arity * 32
+        end.inject(:+)
+      end
+  end
+
+end

data/lib/platon/formatter.rb

@@ -0,0 +1,142 @@
+module Platon
+  class Formatter
+
+    UNITS = {
+      'von':          1,
+      'kvon':         1000,
+      'mvon':         1000000,
+      'gvon':         1000000000,  ## 10 ** 9
+      'microatp':     1000000000000,
+      'milliatp':     1000000000000000,
+      'atp':          1000000000000000000, ## 10 ** 18
+      'katp':         1000000000000000000000,
+      'matp':         1000000000000000000000000,
+      'gatp':         1000000000000000000000000000,
+      'tatp':         1000000000000000000000000000000
+    }
+
+    def valid_address?(address_string)
+      address = address_string.gsub(/^0x/,'')
+      return false if address == "0000000000000000000000000000000000000000"
+      return false if address.length != 40
+      return !(address.match(/[0-9a-fA-F]+/).nil?)
+    end
+
+    def from_bool(boolval)
+      return nil if boolval.nil?
+      boolval ? "1" : "0"
+    end
+
+    def to_bool(hexstring)
+      return nil if hexstring.nil?
+      (hexstring == "0000000000000000000000000000000000000000000000000000000000000001")
+    end
+
+    def to_ascii(hexstring)
+      return nil if hexstring.nil?
+      hexstring.gsub(/^0x/,'').scan(/.{2}/).collect {|x| x.hex}.pack("c*")
+    end
+
+    def to_utf8(hexstring)
+      return nil if hexstring.nil?
+      hexstring.gsub(/^0x/,'').scan(/.{2}/).collect {|x| x.hex}.pack("U*").delete("\u0000")
+    end
+
+    def from_ascii(ascii_string)
+      return nil if ascii_string.nil?
+      ascii_string.unpack('H*')[0]
+    end
+
+    def from_utf8(utf8_string)
+      return nil if utf8_string.nil?
+      utf8_string.force_encoding('UTF-8').split("").collect {|x| x.ord.to_s(16).rjust(2, '0')}.join("")
+    end
+
+    def to_address(hexstring)
+      return "0x0000000000000000000000000000000000000000" if hexstring.nil?
+      "0x" + hexstring[-40..-1]
+    end
+
+    def to_von(amount, unit = "atp") #TODO
+      return nil if amount.nil?
+      BigDecimal(UNITS[unit.to_sym] * amount, 16).to_s.to_i rescue nil
+    end
+
+    def from_von(amount, unit = "atp") #TODO
+      return nil if amount.nil?
+      (BigDecimal(amount, 16) / BigDecimal(UNITS[unit.to_sym], 16)).to_s rescue nil
+    end
+
+    def to_gvon(amount, unit = "gvon") 
+      return nil if amount.nil?
+      BigDecimal(UNITS[unit.to_sym] * amount, 16).to_s.to_i rescue nil
+    end
+
+    def from_gvon(amount, unit = "gvon") 
+      return nil if amount.nil?
+      (BigDecimal(amount, 16) / BigDecimal(UNITS[unit.to_sym], 16)).to_s rescue nil
+    end
+
+    def from_address(address)
+      return "0x0000000000000000000000000000000000000000" if address.nil?
+      address.gsub(/^0x/,'').rjust(64, "0")
+    end
+
+    def to_param(string)
+      string.ljust(64, '0')
+    end
+
+    def from_input(string)
+      string[10..-1].scan(/.{64}/)
+    end
+
+    def to_twos_complement(number)
+      (number & ((1 << 256) - 1)).to_s(16)
+    end
+
+    def to_int(hexstring)
+      return nil if hexstring.nil?
+      (hexstring.gsub(/^0x/,'')[0..1] == "ff") ? (hexstring.hex - (2 ** 256)) : hexstring.hex
+    end
+
+    def get_base_type(typename)
+      typename.gsub(/\d+/,'')
+    end
+
+    def from_payload(args)
+      converter = "output_to_#{self.get_base_type(args[0])}".to_sym
+      self.send(converter, args[1])
+    end
+
+    def output_to_address(bytes)
+      self.to_address(bytes)
+    end
+
+    def output_to_bytes(bytes)
+      self.to_utf8(bytes)
+    end
+
+    def output_to_string(bytes)
+      self.to_utf8(bytes)
+    end
+
+    def output_to_uint(bytes)
+      self.to_int(bytes)
+    end
+
+    def output_to_int(bytes)
+      self.to_int(bytes)
+    end
+
+    def output_to_bool(bytes)
+      self.to_bool(bytes.gsub(/^0x/,''))
+    end
+
+    def to_output(args)
+      converter = "output_to_#{self.get_base_type(args[0])}".to_sym
+      self.send(converter, args[1])
+    end
+
+  end
+
+end