tezos_client 0.2.0

data/lib/tezos_client/operations/origination_operation.rb

@@ -0,0 +1,50 @@
+class TezosClient
+  class OriginationOperation < Operation
+
+    def initialize_operation_args
+      operation_args = default_args.merge(
+        **@init_args,
+        manager: manager,
+        operation_kind: operation_kind,
+        branch: branch,
+        counter: counter)
+
+      if has_script?
+        operation_args[:script] = json_script
+      end
+      @operation_args = operation_args
+    end
+
+    def has_script?
+      @init_args.key? :script
+    end
+
+    def json_script
+      liquidity_interface.origination_script(
+        @init_args.slice(:from, :script, :init_params)
+      )
+    end
+
+    def manager
+      @init_args.fetch(:manager) { @init_args.fetch(:from) }
+    end
+
+
+    def operation_kind
+      :origination
+    end
+
+    private
+
+    def default_args
+      {
+        amount: 0,
+        spendable: false,
+        delegatable: false,
+        gas_limit: 0.1,
+        storage_limit: 0.006,
+        fee: 0.05
+      }
+    end
+  end
+end

data/lib/tezos_client/operations/transaction_operation.rb

@@ -0,0 +1,39 @@
+class TezosClient
+  class TransactionOperation < Operation
+    include EncodeUtils
+
+    def initialize_operation_args
+      @operation_args = default_args.merge(
+        **@init_args,
+        operation_kind: operation_kind,
+        branch: branch,
+        counter: counter
+      )
+      if has_parameters?
+        @operation_args[:parameters] = parameters
+      end
+    end
+
+    def has_parameters?
+      @init_args.key? :parameters
+    end
+
+    def parameters
+      (@init_args[:parameters].is_a? String) ? encode_args(@init_args[:parameters]) : @init_args[:parameters]
+    end
+
+    def operation_kind
+      :transaction
+    end
+
+    private
+
+    def default_args
+      {
+        gas_limit: 0.04,
+        storage_limit: 0.006,
+        fee: 0.05
+      }
+    end
+  end
+end

data/lib/tezos_client/rpc_interface/blocks.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class TezosClient
+  class RpcInterface
+    module Blocks
+      def block(block_hash = "head")
+        get "chains/main/blocks/#{block_hash}"
+      end
+
+      def blocks(length: 50, head: nil, min_date: nil)
+        query = {
+          length: length,
+          head: head,
+          min_date: min_date&.utc&.iso8601
+        }.compact
+
+        res = get "chains/main/blocks/", query: query
+        res[0]
+      end
+
+      def block_header(block_hash = "head")
+        get "chains/main/blocks/#{block_hash}/header"
+      end
+
+      def block_operations(block_hash = "head")
+        get "chains/main/blocks/#{block_hash}/operations"
+      end
+
+      def block_operation_hashes(block_hash = "head")
+        get "chains/main/blocks/#{block_hash}/operation_hashes"
+      end
+    end
+  end
+end

data/lib/tezos_client/rpc_interface/context.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class TezosClient
+  class RpcInterface
+    module Context
+      def constants
+        get "/chains/main/blocks/head/context/constants"
+      end
+
+      def head_hash
+        get "/chains/main/blocks/head/hash"
+      end
+
+      def chain_id
+        get "/chains/main/chain_id"
+      end
+
+      def protocols
+        get "/protocols"
+      end
+
+      def protocol
+        get "/protocols/main"
+      end
+    end
+  end
+end

data/lib/tezos_client/rpc_interface/contracts.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class TezosClient
+  class RpcInterface
+    using CurrencyUtils
+
+    module Contracts
+      def contract_link(contract_id)
+        "/chains/main/blocks/head/context/contracts/#{contract_id}"
+      end
+
+      def balance(contract_id)
+        res = get("#{contract_link(contract_id)}/balance")
+        res.to_i.from_satoshi
+      end
+
+      def contract_counter(contract_id)
+        res = get("#{contract_link(contract_id)}/counter")
+        res.to_i
+      end
+
+      def contract_manager_key(contract_id)
+        get "#{contract_link(contract_id)}/manager_key"
+      end
+    end
+  end
+end

data/lib/tezos_client/rpc_interface/helper.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+class TezosClient
+  class RpcInterface
+    module Helper
+      using CurrencyUtils
+
+      def transaction_operation(args)
+        operation = {
+          kind: "transaction",
+          amount: args.fetch(:amount).to_satoshi.to_s,
+          source: args.fetch(:from),
+          destination: args.fetch(:to),
+          gas_limit: args.fetch(:gas_limit).to_satoshi.to_s,
+          storage_limit: args.fetch(:storage_limit).to_satoshi.to_s,
+          counter: args.fetch(:counter).to_s,
+          fee: args.fetch(:fee).to_satoshi.to_s
+        }
+        operation[:parameters] = args[:parameters] if args[:parameters]
+        operation
+      end
+
+      def origination_operation(args)
+        operation = {
+          kind: "origination",
+          delegatable: args.fetch(:delegatable),
+          spendable: args.fetch(:spendable),
+          balance: args.fetch(:amount).to_satoshi.to_s,
+          source: args.fetch(:from),
+          gas_limit: args.fetch(:gas_limit).to_satoshi.to_s,
+          storage_limit: args.fetch(:storage_limit).to_satoshi.to_s,
+          counter: args.fetch(:counter).to_s,
+          fee: args.fetch(:fee).to_satoshi.to_s,
+          managerPubkey: args.fetch(:manager)
+        }
+
+        operation[:script] = args[:script] if args[:script]
+        operation
+      end
+
+      def operation(args)
+        operation_kind = args.fetch(:operation_kind) { raise ArgumentError, ":operation_kind argument missing" }
+        send("#{operation_kind}_operation", args)
+      end
+
+      %w(origination transaction).each do |operation_kind|
+        # preapply_transaction, preapply_origination ...
+        define_method "preapply_#{operation_kind}" do |args|
+          preapply_operation(operation_kind: operation_kind, **args)
+        end
+
+        # run_transaction, run_origination ...
+        define_method "run_#{operation_kind}" do |args|
+          run_operation(operation_kind: operation_kind, **args)
+        end
+
+        # forge_transaction, forge_origination ...
+        define_method "forge_#{operation_kind}" do |args|
+          forge_operation(operation_kind: operation_kind, **args)
+        end
+      end
+
+
+      def preapply_operation(args)
+        content = {
+          protocol: args.fetch(:protocol),
+          branch: args.fetch(:branch),
+          contents: [operation(args)],
+          signature: args.fetch(:signature)
+        }
+
+        res = post("chains/main/blocks/head/helpers/preapply/operations",
+                   [content])
+        res[0]["contents"][0]
+      end
+
+      def run_operation(args)
+        content = {
+          branch: args.fetch(:branch),
+          contents: [operation(args)],
+          signature: args.fetch(:signature)
+        }
+        res = post("chains/main/blocks/head/helpers/scripts/run_operation", content)
+        res["contents"][0]
+      end
+
+      def forge_operation(args)
+        content = {
+          branch: args.fetch(:branch),
+          contents: [operation(args)]
+        }
+        post("chains/main/blocks/head/helpers/forge/operations", content)
+      end
+
+      def broadcast_operation(data)
+        post("injection/operation?chain=main", data)
+      end
+    end
+  end
+end

data/lib/tezos_client/rpc_interface/monitor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "date"
+
+class TezosClient
+  class RpcInterface
+    module Monitor
+      def bootstrapped
+        res = get "/monitor/bootstrapped"
+        res["timestamp"] = DateTime.parse(res["timestamp"])
+        res
+      end
+
+      def monitor_block(&block_reader)
+        monitor("monitor/heads/main", &block_reader)
+      end
+    end
+  end
+end

data/lib/tezos_client/rpc_interface/request_manager.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class TezosClient
+  class RpcInterface
+    module RequestManager
+      def get(path, query: {})
+        url = "http://#{@host}:#{@port}/#{path}"
+
+        response = HTTParty.get(url, headers: { "Content-Type" => "application/json" }, query: query)
+        formatted_response = format_response(response.parsed_response)
+
+        log("-------")
+        log(">>> GET #{response.request.uri.to_s} \n")
+        log("<<< code: #{response.code} \n #{formatted_response.pretty_inspect}")
+        log("-------")
+        unless response.success?
+          raise "#{url} failed with code #{response.code}: #{formatted_response.pretty_inspect}"
+        end
+
+        formatted_response
+      end
+
+      def post(path, content)
+        url = "http://#{@host}:#{@port}/#{path}"
+        response = HTTParty.post(url,
+                                 body: content.to_json,
+                                 headers: { "Content-Type" => "application/json" })
+
+        formatted_response = format_response(response.parsed_response)
+
+        log("-------")
+        log(">>> POST #{url} \n #{content.pretty_inspect}")
+        log("<<< code: #{response.code} \n #{formatted_response.pretty_inspect}")
+        log("-------")
+
+        unless response.success?
+          raise "#{url} failed with code #{response.code}:\n #{formatted_response.pretty_inspect}"
+        end
+
+        formatted_response
+      end
+
+      def monitor(path, &event_handler)
+        uuid = SecureRandom.uuid
+
+        url = "http://#{@host}:#{@port}/#{path}"
+
+        event_reader = monitor_event_reader(uuid, event_handler)
+
+        Thread.new do
+          log("Monitor #{uuid}: Start monitoring GET #{url}")
+          RestClient::Request.execute(method: :get,
+                                      read_timeout: 60 * 60 * 24 * 365,
+                                      url: url,
+                                      block_response: event_reader,
+                                      content_type: :json,
+                                      accept: :json)
+        rescue => e
+          log "#{uuid}: failed with error #{e}"
+        end
+      end
+
+      private
+
+      def monitor_event_reader(uuid, event_handler)
+        proc do |event_response|
+          event_response.read_body do |event_json|
+            event = format_response(JSON.parse(event_json))
+            log("Monitor #{uuid}: received chunk #{event.pretty_inspect}")
+            event_handler.call(event)
+          end
+        end
+      end
+
+      def format_response(response)
+        if response.is_a? Array
+          response.map do |el|
+            (el.is_a? Hash) ? el.with_indifferent_access : el
+          end
+        elsif response.is_a? Hash
+          response.with_indifferent_access
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/tezos_client/rpc_interface.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "rest-client"
+
+require_relative "rpc_interface/monitor"
+require_relative "rpc_interface/contracts"
+require_relative "rpc_interface/context"
+require_relative "rpc_interface/helper"
+require_relative "rpc_interface/request_manager"
+require_relative "rpc_interface/blocks"
+
+class TezosClient
+  class RpcInterface
+    include Logger
+    include Monitor
+    include Contracts
+    include Context
+    include Helper
+    include RequestManager
+    include Blocks
+
+    def initialize(host: "127.0.0.1", port: "8732")
+      @host = host
+      @port = port
+    end
+
+  end
+end

data/lib/tezos_client/string_utils.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+
+class TezosClient
+  module StringUtils
+    refine String do
+      def to_hex
+        unpack("H*")[0]
+      end
+
+      def to_bin
+        [self].pack("H*")
+      end
+    end
+  end
+end

data/lib/tezos_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TezosClient
+  VERSION = "0.2.0"
+end

data/lib/tezos_client.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "pp"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/string/inflections"
+require "timeout"
+
+require "tezos_client/version"
+require "tezos_client/string_utils"
+require "tezos_client/currency_utils"
+require "tezos_client/crypto"
+require "tezos_client/commands"
+require "tezos_client/logger"
+require "tezos_client/encode_utils"
+require "tezos_client/operation"
+require "tezos_client/operations/origination_operation"
+require "tezos_client/operations/transaction_operation"
+
+require "tezos_client/client_interface"
+require "tezos_client/rpc_interface"
+require "tezos_client/liquidity_interface"
+
+
+class TezosClient
+  using CurrencyUtils
+  using StringUtils
+
+  include Logger
+
+  include Commands
+  include Crypto
+
+  attr_accessor :client_interface
+  attr_accessor :rpc_interface
+  attr_accessor :liquidity_interface
+
+  RANDOM_SIGNATURE = "edsigu165B7VFf3Dpw2QABVzEtCxJY2gsNBNcE3Ti7rRxtDUjqTFRpg67EdAQmY6YWPE5tKJDMnSTJDFu65gic8uLjbW2YwGvAZ"
+
+  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
+
+    @client_config_file = ENV["TEZOS_CLIENT_CONFIG_FILE"]
+    @client_interface = ClientInterface.new(
+      config_file: @client_config_file
+    )
+
+    @rpc_interface = RpcInterface.new(
+      host: @rpc_node_address,
+      port: @rpc_node_port
+    )
+
+    @liquidity_interface = LiquidityInterface.new(
+      rpc_node_address: @rpc_node_address,
+      rpc_node_port: @rpc_node_port
+    )
+  end
+
+  # Originates a contract on the tezos blockchain
+  #
+  # @param from [String] Address originating the contract
+  # @param amount [Numeric] amount to send to the contract
+  # @param secret_key [String] Secret key of the origination address
+  # @param args [Hash] keyword options for the origination
+  # @option args [String] :script path of the liquidity script
+  # @option args [Array, String] :init_params params to pass to the storage initialization process
+  # @option args [Boolean] :spendable decide wether the contract is spendable or not
+  # @option args [Boolean] :delegatable decide wether the contract is delegatable or not
+  #
+  # @return [Hash] result of the origination containing :operation_id, :operation_result and :originated_contract
+  #
+  def originate_contract(from:, amount:, secret_key:, **args)
+    res = OriginationOperation.new(
+      liquidity_interface: liquidity_interface,
+      rpc_interface: rpc_interface,
+      from: from,
+      secret_key: secret_key,
+      amount: amount,
+      **args
+    ).test_and_broadcast
+
+    res.merge(originated_contract: res[:operation_result][:originated_contracts][0])
+  end
+
+  # Transfer funds to an account
+  #
+  # @param from [String] Address originating the transfer
+  # @param to [String] Address receiving the transfer
+  # @param amount [Numeric] amount to send to the account
+  # @param secret_key [String] Secret key of the origination address
+  # @param args [Hash] keyword options for the transfer
+  #
+  # @return [Hash] result of the transfer containing :operation_id and :operation_result
+  #
+  def transfer(from:, amount:, to:, secret_key:, **args)
+    TransactionOperation.new(
+      liquidity_interface: liquidity_interface,
+      rpc_interface: rpc_interface,
+      from: from,
+      to: to,
+      secret_key: secret_key,
+      amount: amount,
+      **args
+    ).test_and_broadcast
+  end
+
+  def call_contract(args)
+    parameters = args.fetch(:parameters)
+
+    json_params = liquidity_interface.call_parameters(
+      script: args.fetch(:script),
+      parameters: parameters
+    )
+
+    transfer_args = args.merge(parameters: json_params)
+
+    transfer(transfer_args)
+  end
+
+  def monitor_operation(operation_id, timeout: 120)
+    including_block = nil
+
+    monitoring_thread = rpc_interface.monitor_block do |block_header|
+      log "recently received block: #{block_header.pretty_inspect}"
+      hash = block_header["hash"]
+      if block_include_operation?(operation_id, hash)
+        log "operations #{operation_id} found in block #{hash}"
+        including_block = hash
+      end
+    end
+
+    Timeout.timeout(timeout) do
+      loop do
+        sleep(0.1)
+        break unless including_block.nil?
+      end
+    end
+
+    monitoring_thread.terminate
+
+    including_block
+  end
+
+  def block_include_operation?(operation_id, block_id)
+    operations = rpc_interface.get("chains/main/blocks/#{block_id}/operation_hashes")
+    operations.flatten.include? operation_id
+  end
+
+end

data/tezos_client.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "tezos_client/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "tezos_client"
+  spec.version       = TezosClient::VERSION
+  spec.authors       = ["Pierre Michard"]
+  spec.email         = ["pierre@moneytrack.io"]
+
+  spec.summary       = "Wrapper to the tezos client."
+  spec.description   = ""
+  spec.homepage      = "http://moneytrack.io"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop-rails_config"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr", "~> 4.0.0"
+
+  spec.add_dependency "base58", "~> 0.2.3"
+  spec.add_dependency "httparty", "~> 0.16.2"
+  spec.add_dependency "rbnacl", "~> 5.0.0"
+  spec.add_dependency "rest-client", "~>2.0.0"
+  spec.add_dependency "activesupport", "~> 5.2.0"
+end

data/travis-scripts/install-liquidity.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+#set -ex
+# This script is used in .travis.yml for continuous integration on travis.
+# BTW, it also show some needed system packages to build liquidity
+# Travis CI is done on Ubuntu trusty
+
+[ -d liquidity ] || git clone --depth=50 https://github.com/OCamlPro/liquidity.git liquidity
+cd liquidity
+git pull
+git checkout next
+
+# currently, we only target OCaml 4.06.1 because we reuse the parser of OCaml
+opam switch create liquidity 4.06.1
+
+eval $(opam config env)
+opam update
+eval $(opam config env)
+
+make build-deps
+make clone-tezos
+tezos/scripts/install_build_deps.raw.sh
+# make -C tezos build-deps
+
+make
+make install

data/travis-scripts/install-opam.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+set -ex
+wget https://raw.githubusercontent.com/ocaml/opam/master/shell/install.sh
+yes "" | sh install.sh

data/travis-scripts/prepare-trusty.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+# This script is used in .travis.yml for continuous integration on travis.
+# BTW, it also show some needed system packages to build liquidity.
+# Travis CI is done on Ubuntu trusty
+
+sudo apt-get update -qq
+sudo apt-get install -y -qq libgmp-dev pandoc # ocaml ocaml-native-compilers
+
+# do this in a second step to only install libsecp256k1-dev libsecp256k1-0
+# for ubuntu, these packages are not available in trusty
+sudo add-apt-repository "deb http://cz.archive.ubuntu.com/ubuntu artful main universe"
+sudo apt-get update -qq
+sudo apt-get install -y -qq \
+     libsecp256k1-dev libsecp256k1-0 libsodium-dev libssl-dev \
+     bubblewrap libev-dev libhidapi-dev
+