tezos_client 0.2.0

data/lib/tezos_client/crypto.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "base58"
+require "rbnacl"
+require "digest"
+
+class TezosClient
+  module Crypto
+    using StringUtils
+
+    PREFIXES = {
+      tz1:    [6, 161, 159],
+      tz2:    [6, 161, 161],
+      tz3:    [6, 161, 164],
+      KT:     [2, 90, 121],
+      edpk:   [13, 15, 37, 217],
+      edsk2:  [13, 15, 58, 7],
+      spsk:   [17, 162, 224, 201],
+      p2sk:   [16, 81, 238, 189],
+      sppk:   [3, 254, 226, 86],
+      p2pk:   [3, 178, 139, 127],
+      edsk:   [43, 246, 78, 7],
+      edsig:  [9, 245, 205, 134, 18],
+      spsig1: [13, 115, 101, 19, 63],
+      p2sig:  [54, 240, 44, 52],
+      sig:    [4, 130, 43],
+      Net:    [87, 82, 0],
+      nce:    [69, 220, 169],
+      b:      [1, 52],
+      o:      [5, 116],
+      Lo:     [133, 233],
+      LLo:    [29, 159, 109],
+      P:      [2, 170],
+      Co:     [79, 179],
+      id:     [153, 103]
+    }.freeze
+
+    WATERMARK = {
+      block: "01",
+      endorsement: "02",
+      generic: "03"
+    }.freeze
+
+    def hex_prefix(type)
+      PREFIXES[type].pack("C*").to_hex
+    end
+
+    def decode_base58(base58_val)
+      bin_val = Base58.base58_to_binary(base58_val, :bitcoin)
+      bin_val.to_hex
+    end
+
+    def encode_base58(hex_val)
+      bin_val = hex_val.to_bin
+      Base58.binary_to_base58(bin_val, :bitcoin)
+    end
+
+    def checksum(hex)
+      b = hex.to_bin
+      Digest::SHA256.hexdigest(Digest::SHA256.digest(b))[0...8]
+    end
+
+    def get_prefix_and_payload(str)
+      PREFIXES.keys.each do |prefix|
+        if str.start_with? hex_prefix(prefix)
+          return prefix, str[(hex_prefix(prefix).size) .. -1]
+        end
+      end
+    end
+
+    def decode_tz(str)
+      decoded = decode_base58 str
+
+      unless checksum(decoded[0...-8]) != decoded[0...-8]
+        raise "invalid checksum for #{str}"
+      end
+
+      prefix, payload = get_prefix_and_payload(decoded[0...-8])
+
+      yield(prefix, payload) if block_given?
+
+      payload
+    end
+
+    def encode_tz(prefix, str)
+      prefixed = hex_prefix(prefix) + str
+      checksum = checksum(prefixed)
+
+      encode_base58(prefixed + checksum)
+    end
+
+    def secret_key_to_public_key(secret_key)
+      signing_key = signing_key(secret_key)
+      verify_key = signing_key.verify_key
+      hex_pubkey = verify_key.to_s.to_hex
+
+      encode_tz(:edpk, hex_pubkey)
+    end
+
+    def public_key_to_address(public_key)
+      public_key = decode_tz(public_key) do |type, _key|
+        raise "invalid public key: #{public_key} " unless type == :edpk
+      end
+
+      hash = RbNaCl::Hash::Blake2b.digest(public_key, digest_size: 20)
+      hex_hash = hash.to_hex
+
+      encode_tz(:tz1, hex_hash)
+    end
+
+    def generate_key
+      signing_key = RbNaCl::SigningKey.generate.to_bytes.to_hex
+
+      secret_key = encode_tz(:edsk2, signing_key)
+      public_key = secret_key_to_public_key(secret_key)
+      address = public_key_to_address(public_key)
+
+      {
+        secret_key: secret_key,
+        public_key: public_key,
+        address: address
+      }
+    end
+
+    def signing_key(secret_key)
+      secret_key = decode_tz(secret_key) do |type, _key|
+        raise "invalid secret key: #{secret_key} " unless type == :edsk2
+      end
+
+      RbNaCl::SigningKey.new(secret_key.to_bin)
+    end
+
+    def sign_bytes(secret_key:, data:, watermark: nil)
+      watermarked_data = if watermark.nil?
+        data
+      else
+        WATERMARK[watermark] + data
+      end
+
+      hash = RbNaCl::Hash::Blake2b.digest(watermarked_data.to_bin, digest_size: 32)
+
+      signing_key = signing_key(secret_key)
+      bin_signature = signing_key.sign(hash)
+
+      edsig = encode_tz(:edsig, bin_signature.to_hex)
+      signed_data = data + bin_signature.to_hex
+
+      if block_given?
+        yield(edsig, signed_data)
+      else
+        edsig
+      end
+    end
+
+    def operation_id(signed_operation_hex)
+      hash = RbNaCl::Hash::Blake2b.digest(
+        signed_operation_hex.to_bin,
+        digest_size: 32
+      )
+      encode_tz(:o, hash.to_hex)
+    end
+
+
+    def sign_operation(secret_key:, operation_hex:)
+      sign_bytes(secret_key: secret_key,
+                 data: operation_hex,
+                 watermark: :generic) do |edsig, signed_data|
+        op_id = operation_id(signed_data)
+
+        if block_given?
+          yield(edsig, signed_data, op_id)
+        else
+          edsig
+        end
+      end
+    end
+  end
+end

data/lib/tezos_client/currency_utils.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+class TezosClient
+  module CurrencyUtils
+    TEZOS_SATOSHI = 1000000.0
+
+    refine Numeric do
+      def from_satoshi
+        self.to_d / TEZOS_SATOSHI
+      end
+
+      def to_satoshi
+        (self * TEZOS_SATOSHI).to_i
+      end
+    end
+  end
+end

data/lib/tezos_client/encode_utils.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class TezosClient
+  module EncodeUtils
+    class ArgsEncoder
+      attr_accessor :expr, :popen, :sopen, :escaped, :pl, :ret
+
+
+      def initialize(expr)
+        @expr = expr.gsub(/(?:@[a-z_]+)|(?:#.*$)/m, "")
+                    .gsub(/\s+/, " ")
+                    .strip
+        initialize_statuses
+        initialize_ret
+      end
+
+      def initialize_statuses
+        @popen = false
+        @sopen = false
+        @escaped = false
+        @pl = 0
+        @val = ""
+      end
+
+      def initialize_ret
+        @ret = {
+          prim: nil,
+          args: []
+        }
+      end
+
+      def treat_val
+        unless @val.empty?
+          if @val == @val.to_i.to_s
+            if !ret[:prim]
+              @ret = { "int" => @val }
+            else
+              @ret[:args] << { "int" => @val }
+            end
+          elsif ret[:prim]
+            @ret[:args] << ArgsEncoder.new(@val).encode
+          else
+            @ret[:prim] = @val
+          end
+          @val = ""
+        end
+      end
+
+      def treat_double_quote(char)
+        return false unless char == '"'
+
+        if @sopen
+          @sopen = false
+          if !ret[:prim]
+            @ret = { "string" => @val }
+          else
+            @ret[:args] << { "string" => @val }
+          end
+          @val = ""
+        else
+          @sopen = true
+        end
+        true
+      end
+
+      def treat_parenthesis(char)
+        case char
+        when "("
+          @val += char if @popen
+          @popen = true
+          @pl += 1
+          true
+        when ")"
+          raise "closing parenthesis while none was opened #{val}" unless popen
+          @pl -= 1
+          if pl.zero?
+            @ret[:args] << ArgsEncoder.new(@val).encode
+            @val = ""
+            @popen = false
+          else
+            @val += char
+          end
+          true
+        else
+          false
+        end
+      end
+
+      def treat_escape(char)
+        if escaped
+          @val += char
+          @escaped = false
+          true
+        elsif char == "\\"
+          @escaped = true
+          true
+        end
+        false
+      end
+
+      def treat_char(char, is_last_char)
+        return if treat_escape(char)
+
+        unless popen || sopen
+          if is_last_char || char == " "
+            @val += char if is_last_char
+            treat_val
+            return
+          end
+        end
+
+        unless popen
+          return if treat_double_quote(char)
+        end
+
+        return if treat_parenthesis(char)
+
+        @val += char
+      end
+
+      def encode
+        expr.each_char.with_index do |char, i|
+          is_last_char = (i == (expr.length - 1))
+          treat_char(char, is_last_char)
+        end
+
+        if sopen
+          raise ArgumentError, "string '#{@val}' has not been closed"
+        end
+
+        ret
+      end
+    end
+
+    def encode_args(expr)
+      ArgsEncoder.new(expr).encode
+    end
+  end
+end

data/lib/tezos_client/liquidity_inteface/liquidity_wrapper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class TezosClient
+  class LiquidityInterface
+    # Wrapper used to call the tezos-client binary
+    module LiquidityWrapper
+      def call_liquidity(command)
+        cmd = "#{liquidity_cmd} #{command}"
+        log cmd
+        Open3.popen3(cmd) do |_stdin, stdout, stderr, wait_thr|
+          err = stderr.read
+          status = wait_thr.value.exitstatus
+
+          if status != 0
+            raise "command '#{cmd}' existed with status #{status}: #{err}"
+          end
+
+          log err
+          output = stdout.read
+
+          if block_given?
+            yield(output)
+          else
+            output
+          end
+        end
+      end
+
+      def liquidity_cmd
+        "liquidity --tezos-node #{tezos_node}"
+      end
+    end
+  end
+end

data/lib/tezos_client/liquidity_interface.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "liquidity_inteface/liquidity_wrapper"
+
+class TezosClient
+  class LiquidityInterface
+    include Logger
+    include LiquidityWrapper
+
+    def initialize(rpc_node_address: "127.0.0.1", rpc_node_port: 8732)
+      @rpc_node_address = rpc_node_address
+      @rpc_node_port = rpc_node_port
+    end
+
+    def format_params(params)
+      params = [params] if params.is_a? String
+      params.map { |s| "'#{s}'" }.join(" ")
+    end
+
+    def initial_storage(args)
+      from = args.fetch :from
+      script = args.fetch :script
+      init_params = args.fetch :init_params
+      init_params = format_params(init_params)
+
+      with_tempfile(".json") do |json_file|
+        call_liquidity "--source #{from} --json #{script} -o #{json_file.path} --init-storage #{init_params}"
+        JSON.parse json_file.read.strip
+      end
+    end
+
+    def with_tempfile(extension)
+      file = Tempfile.new(["script", extension])
+      yield(file)
+
+    ensure
+      file.unlink
+    end
+
+    def with_file_copy(source_file_path)
+      source_file = File.open(source_file_path, "r")
+      source_extention = File.extname(source_file_path)
+
+      file_copy_path = nil
+
+      res = with_tempfile(source_extention) do |file_copy|
+        file_copy.write(source_file.read)
+        file_copy_path = file_copy.path
+        file_copy.close
+        yield(file_copy_path)
+      end
+
+      res
+    ensure
+      File.delete(file_copy_path) if File.exists? file_copy_path
+    end
+
+    def json_scripts(args)
+      with_file_copy(args[:script]) do |script_copy_path|
+        json_init_script_path = "#{script_copy_path}.initializer.tz.json"
+        json_contract_script_path = "#{script_copy_path}.tz.json"
+
+        call_liquidity "--json #{script_copy_path}"
+
+        json_contract_script_file = File.open(json_contract_script_path)
+        json_contract_script = JSON.parse(json_contract_script_file.read)
+        json_contract_script_file.close
+
+        if File.exists? json_init_script_path
+          json_init_script_file = File.open(json_init_script_path)
+          json_init_script = JSON.parse(json_init_script_file.read)
+          json_init_script_file.close
+        end
+
+        if block_given?
+          yield(json_init_script, json_contract_script)
+        else
+          return json_init_script, json_contract_script
+        end
+
+      ensure
+        [json_init_script_path, json_contract_script_path].each do |file_path|
+          File.delete file_path if File.exists? file_path
+        end
+      end
+    end
+
+    def origination_script(args)
+      storage = initial_storage(args)
+      _json_init_script, json_contract_script = json_scripts(args)
+
+      {
+        code: json_contract_script,
+        storage: storage
+      }
+    end
+
+    def forge_deploy(args)
+      amount = args.fetch(:amount, 0)
+      spendable = args.fetch(:spendable, false)
+      delegatable = args.fetch(:delegatable, false)
+      source = args.fetch :from
+      script = args.fetch :script
+      init_params = args.fetch :init_params
+
+      res = call_liquidity "--source #{source} #{spendable ? '--spendable' : ''} #{delegatable ? '--delegatable' : ''} --amount #{amount}tz #{script} --forge-deploy '#{init_params}'"
+      res.strip
+    end
+
+    def tezos_node
+      "#{@rpc_node_address}:#{@rpc_node_port}"
+    end
+
+    def get_storage(script:, contract_address:)
+      res = call_liquidity "#{script} --get-storage #{contract_address}"
+      res.strip
+    end
+
+    def call_parameters(script:, parameters:)
+      parameters = format_params(parameters)
+      with_tempfile(".json") do |json_file|
+        res = call_liquidity "--json -o #{json_file.path} #{script} --data #{parameters}"
+        JSON.parse res
+      end
+    end
+  end
+end

data/lib/tezos_client/logger.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require "active_support/concern"
+
+class TezosClient
+  module Logger
+    extend ActiveSupport::Concern
+    @@logger = nil
+    @@env_logger = nil
+
+    def log(out)
+      return unless self.class.logger
+      self.class.logger << out + "\n"
+    end
+
+    class_methods do
+      # Setup the log for TezosClient calls.
+      # Value should be a logger but can can be stdout, stderr, or a filename.
+      # You can also configure logging by the environment variable TEZOSCLIENT_LOG.
+      def logger=(log)
+        @@logger = create_logger log
+      end
+
+      class StdOutLogger
+        def <<(obj)
+          STDOUT.puts obj
+        end
+      end
+
+      class StdErrLogger
+        def <<(obj)
+          STDERR.puts obj
+        end
+      end
+
+      class FileLogger
+        attr_writer :target_file
+
+        def initialize(target_file)
+          @target_file = target_file
+        end
+
+        def <<(obj)
+          File.open(@target_file, "a") { |f| f.puts obj }
+        end
+      end
+
+      # Create a log that respond to << like a logger
+      # param can be 'stdout', 'stderr', a string (then we will log to that file) or a logger (then we return it)
+      def create_logger(param)
+        return unless param
+
+        if param.is_a? String
+          if param == "stdout"
+            StdOutLogger.new
+          elsif param == "stderr"
+            StdErrLogger.new
+          else
+            FileLogger.new(param)
+          end
+        else
+          param
+        end
+      end
+
+      def env_logger
+        if @@env_logger
+          @@env_logger
+        elsif ENV["TEZOSCLIENT_LOG"]
+          @@env_logger = create_logger ENV["TEZOSCLIENT_LOG"]
+        end
+      end
+
+      def logger
+        @@logger || env_logger
+      end
+    end
+  end
+end

data/lib/tezos_client/operation.rb

@@ -0,0 +1,125 @@
+
+class TezosClient
+
+  class Operation
+    include Crypto
+    using CurrencyUtils
+
+    attr_accessor :liquidity_interface,
+                  :rpc_interface,
+                  :base_58_signature,
+                  :signed_hex,
+                  :from,
+                  :operation_args,
+                  :rpc_args
+
+    def initialize(liquidity_interface:, rpc_interface:, **args)
+      @liquidity_interface = liquidity_interface
+      @rpc_interface = rpc_interface
+      @from = args.fetch(:from) { raise ArgumentError, "Argument :from missing" }
+      @secret_key = args.fetch(:secret_key)
+      @init_args = args
+      @signed = false
+      @operation_args = {}
+      initialize_operation_args
+      @rpc_args = rpc_interface.operation(@operation_args)
+    end
+
+    def initialize_operation_args
+      raise NotImplementedError.new("#{self.class.name}##{__method__} is an abstract method.")
+    end
+
+    def operation_kind
+      raise NotImplementedError.new("#{self.class.name}##{__method__} is an abstract method.")
+    end
+
+    def branch
+      rpc_interface.head_hash
+    end
+
+    def counter
+      @init_args.fetch(:counter) { rpc_interface.contract_counter(from) + 1 }
+    end
+
+    def protocol
+      rpc_interface.protocols[0]
+    end
+
+    def simulate_and_update_limits
+      run_result = run
+
+      @operation_args[:gas_limit] = run_result[:consumed_gas] + 0.01
+      @operation_args[:storage_limit] = run_result[:consumed_storage]
+    end
+
+    def to_hex
+      rpc_interface.forge_operation(operation_args)
+    end
+
+    def sign
+      sign_operation(
+        secret_key: @secret_key,
+        operation_hex: to_hex
+      ) do |base_58_signature, signed_hex, _op_id|
+        @base_58_signature = base_58_signature
+        @signed_hex = signed_hex
+      end
+
+      @signed = true
+    end
+
+    def test_and_broadcast
+      # simulate operations and adjust gas limits
+      simulate_and_update_limits
+      sign
+      operation_result = preapply
+      op_id = broadcast
+      {
+        operation_id: op_id,
+        operation_result: operation_result
+      }
+    end
+
+    def run
+      rpc_response = rpc_interface.run_operation(**operation_args, signature: RANDOM_SIGNATURE)
+
+      operation_result = ensure_applied!(rpc_response)
+
+      consumed_storage = operation_result.fetch(:paid_storage_size_diff, "0").to_i.from_satoshi
+      consumed_gas = operation_result.fetch(:consumed_gas, "0").to_i.from_satoshi
+
+      {
+        status: :applied,
+        consumed_gas: consumed_gas,
+        consumed_storage: consumed_storage,
+        operation_result: operation_result
+      }
+    end
+
+    def preapply
+      raise "can not preapply unsigned operations" unless @signed
+
+      res = rpc_interface.preapply_operation(
+        **operation_args,
+        signature: base_58_signature,
+        protocol: protocol)
+
+      ensure_applied!(res)
+    end
+
+    def broadcast
+      raise "can not preapply unsigned operations" unless @signed
+      rpc_interface.broadcast_operation(signed_hex)
+    end
+
+
+    private
+
+    def ensure_applied!(rpc_response)
+      operation_result = rpc_response[:metadata][:operation_result]
+      status = operation_result[:status]
+      raise "Operation status != 'applied': #{status}\n #{rpc_response.pretty_inspect}" if status != "applied"
+      operation_result
+    end
+  end
+end