ultex-eos 0.2.1

data/docs/deposit.md

@@ -0,0 +1,5 @@
+# Deposit addresses.
+
+For EOS and all others eosio.token deposits we use one EOS account which is defined like deposit wallet address in peatio.
+In Peatio EOS plugin we will define owner of deposit by user unige identifier (UID), 
+uid should be sended like memo, so it's very important to always send this memo to get your deposit in peatio

data/docs/integration.md

@@ -0,0 +1,31 @@
+# Integration.
+
+For Peatio Eos plugin integration you need to do the following steps:
+
+## Image Build.
+
+1. Add peatio-eos gem into your Gemfile.plugin
+```ruby
+gem 'peatio-eos', '~> 0.1.0'
+```
+
+2. Run `bundle install` for updating Gemfile.lock
+
+3. Build custom Peatio [docker image with Eos plugin](https://github.com/rubykube/peatio/blob/master/docs/plugins.md#build)
+
+4. Push your image using `docker push`
+
+5. Update your deployment to use image with peatio-eos gem
+
+## Peatio Configuration.
+
+1. Create EOS Blockchain [config example](../config/blockchains.yml).
+    * In EOS blockchain blocks goes very fast, so to don't fall behind with blocks from your node we recommend to set step at least to 50 and confirmations at least to 20
+
+2. Create EOS Currency [config example](../config/currencies.yml).
+    * No additional steps are needed
+
+3. Create EOS Wallets [config example](../config/wallets.yml)(deposit and hot wallets are required).
+    * Be sure that you have eos_token_name option filled even for EOS currency itself
+    * We need to communicate with keosd to sign transaction, keosd is running on non default eos port which is 8900 and passed to json_rpc function when we sign
+    transaction

data/docs/rpc.md

@@ -0,0 +1,28 @@
+# RPC Calls
+
+The next list of RPC calls where used for plugin development.
+For response examples see spec/resources:
+
+  * /v1/chain/get_info
+    `curl http://127.0.0.1:8888/v1/chain/get_info`
+
+  * /v1/chain/get_block
+    `curl  -X POST -d '{"block_num_or_id": <needed_block_num>}' http://127.0.0.1:8888/v1/chain/get_block`
+
+  * /v1/chain/get_currency_balance
+    `curl  -X POST -d '{"account": "<your_accont_name>", "code": "eosio.token"}' http://127.0.0.1:8888/v1/chain/get_currency_balance`
+
+The next three calls where used to push transaction, for this calls you need to pass json with params which are needed for successfull creation of transaction
+Example of such json's can be found in lib/peatio/eos/transaction_json.rb  
+
+  * /v1/chain/abi_json_to_bin
+    `curl  -X POST -d @<json_file_with_info_which_you_need_to_encode> http://127.0.0.1:8888/v1/chain/abi_json_to_bin`
+    
+
+  **Sign transaction call goes to _/wallet_ route because [keosd](https://developers.eos.io/eosio-nodeos/v1.2.0/docs/keosd-overview) handle everything related to wallets, by default keosd is running on port 8900**
+
+  * /v1/wallet/sign_transaction
+    `curl  -X POST -d @<json_file_with_transaction_which_you_need_to_sign> http://127.0.0.1:8900/v1/wallet/sign_transaction`
+  
+  * /v1/chain/push_transaction
+    `curl  -X POST -d @<json_file_with_signed_transaction_to_push> http://127.0.0.1:8888/v1/chain/push_transaction`

data/docs/testnet.md

@@ -0,0 +1,13 @@
+# Getting Eos in testnet.
+
+## Faucet
+
+* [monitor.jungletestnet.io](https://monitor.jungletestnet.io/#faucet)
+
+## Wallet
+
+* [monitor.jungletestnet.io](https://monitor.jungletestnet.io/#accountInfo)
+
+## Explorer
+
+* [jungle.bloks.io](https://jungle.bloks.io)

data/docs/tokens.md

@@ -0,0 +1,6 @@
+# EOS tokens
+
+EOS blockchain use eosio.token as a standard for tokens.
+EOS itself is also token. 
+Everything that you need to do to integrate some eos token is to add in options eos_token_name option and fill it with the name of token.
+This Option is also not optional even for eos itself, as long as it's also eosio.token

data/lib/ultex/eos.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "ultex/eos/version"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/enumerable"
+require "peatio"
+
+module Peatio
+  module Eos
+    require "bigdecimal"
+    require "bigdecimal/util"
+
+    require "ultex/eos/blockchain"
+    require "ultex/eos/client"
+    require "ultex/eos/wallet"
+    require "ultex/eos/transaction_serializer"
+
+    require "ultex/eos/hooks"
+    require "ultex/eos/version"
+  end
+end

data/lib/ultex/eos/blockchain.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Peatio
+  module Eos
+    class Blockchain < Peatio::Blockchain::Abstract
+      DEFAULT_FEATURES = {case_sensitive: true, cash_addr_format: false}.freeze
+
+      TOKEN_STANDARD = "eosio.token"
+
+      class MissingTokenNameError < Peatio::Blockchain::Error; end
+      class UndefinedCurrencyError < Peatio::Blockchain::Error; end
+
+      def initialize(custom_features={})
+        @features = DEFAULT_FEATURES.merge(custom_features).slice(*SUPPORTED_FEATURES)
+        @settings = {}
+      end
+
+      def configure(settings={})
+        # Clean client state during configure.
+        @client = nil
+
+        supported_settings = settings.slice(*SUPPORTED_SETTINGS)
+        supported_settings[:currencies]&.each do |c|
+          raise MissingTokenNameError, c[:id] if c.dig(:options, :eos_token_name).blank?
+        end
+        @settings.merge!(supported_settings)
+      end
+
+      def fetch_block!(block_number)
+        client.json_rpc("/v1/chain/get_block", "block_num_or_id" => block_number)
+              .fetch("transactions").each_with_object([]) do |tx, txs_array|
+          txs = build_transaction(tx).map do |ntx|
+            Peatio::Transaction.new(ntx.merge(block_number: block_number))
+          end
+          txs_array.append(*txs)
+        end.yield_self {|txs_array| Peatio::Block.new(block_number, txs_array) }
+      rescue Peatio::Eos::Client::Error => e
+        raise Peatio::Blockchain::ClientError, e
+      end
+
+      def load_balance_of_address!(address, currency_id)
+        currency = settings_fetch(:currencies).find {|c| c[:id] == currency_id }
+        raise UndefinedCurrencyError unless currency
+
+        balance = client.json_rpc("/v1/chain/get_currency_balance",
+                                  "account" => address, "code" => TOKEN_STANDARD)
+                        .find {|b| b.split[1] == currency.dig(:options, :eos_token_name) }
+
+        # EOS return array with balances for all eosio.token currencies
+        balance.blank? ? 0 : normalize_balance(balance, currency)
+      rescue Peatio::Eos::Client::Error => e
+        raise Peatio::Wallet::ClientError, e
+      end
+
+      def latest_block_number
+        client.json_rpc("/v1/chain/get_info").fetch("head_block_num")
+      rescue Peatio::Eos::Client::Error => e
+        raise Peatio::Blockchain::ClientError, e
+      end
+
+      private
+
+      def build_transaction(tx)
+        return [] if tx["trx"]["id"].blank? # check for deferred transaction
+
+        tx.dig("trx", "transaction", "actions")
+          .each_with_object([]).with_index do |(entry, formatted_txs), i|
+          next unless entry["name"] == "transfer" && !entry["data"]["to"].empty?
+
+          amount, token_name = entry["data"]["quantity"]&.split
+          next if token_name.nil? || amount.to_d < 0
+
+          currencies = settings_fetch(:currencies).select {|c| c.dig(:options, :eos_token_name) == token_name }
+          status = tx["status"] == "executed" ? "success" : "failed"
+          address = "#{entry['data']['to']}?memo=#{get_memo(entry['data']['memo'])}"
+
+          # Build transaction for each currency belonging to blockchain.
+
+          currencies.pluck(:id).each do |currency_id|
+            formatted_txs << {hash: tx["trx"]["id"],
+                               txout: i,
+                               to_address: address,
+                               amount: amount.to_d,
+                               status: status,
+                               currency_id: currency_id}
+          end
+        end
+      end
+
+      def normalize_balance(balance, currency)
+        balance.chomp(currency.dig(:options, :eos_token_name)).to_d
+      end
+
+      def get_memo(memo)
+        memo.match(/\bID[A-Z0-9]{10}\z/) ? memo : ""
+      end
+
+      def client
+        @client ||= Peatio::Eos::Client.new(settings_fetch(:server))
+      end
+
+      def settings_fetch(key)
+        @settings.fetch(key) { raise Peatio::Blockchain::MissingSettingError, key.to_s }
+      end
+    end
+  end
+end

data/lib/ultex/eos/client.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "memoist"
+require "faraday"
+require "better-faraday"
+
+module Peatio
+  module Eos
+    class Client
+      Error = Class.new(StandardError)
+      class ConnectionError < Error; end
+
+      class ResponseError < StandardError
+        def initialize(code, msg)
+          super "#{msg} (#{code})"
+        end
+      end
+
+      extend Memoist
+
+      def initialize(endpoint, idle_timeout: 500)
+        @rpc_endpoint = URI.parse(endpoint)
+        @idle_timeout = idle_timeout
+      end
+
+      def json_rpc(path, params=nil, port=nil)
+        # We need to communicate with keosd to sign transaction,
+        # keosd is running on non default eos port which is 8900
+        # and passed to json_rpc function when we sign transaction
+        rpc = URI.parse(@rpc_endpoint.to_s)
+        rpc.port = (port.present? ? port : @rpc_endpoint.port)
+        response = connection(rpc).post do |req|
+          req.url path
+
+          # To communicate with keosd to sign transaction we need to pass Host param with keosd port
+          req.headers["Host"] = "0.0.0.0:#{port}" if port.present?
+          req.headers["Content-Type"] = "application/json"
+          req.body = params.to_json if params.present?
+          req.options.timeout = 120
+        end
+        response.assert_success!
+        response = JSON.parse(response.body)
+        return response if response.is_a?(Array) # get balance call return an array
+
+        response["error"].tap {|error| raise ResponseError.new(error["code"], error["message"]) if error }
+        response
+      rescue Faraday::Error => e
+        raise ConnectionError, e
+      rescue StandardError => e
+        raise Error, e
+      end
+
+      private
+
+      def connection(rpc)
+        Faraday.new(rpc) do |f|
+          f.adapter :net_http_persistent,
+                    pool_size: 5,
+                    idle_timeout: @idle_timeout,
+                    open_timeout: @idle_timeout,
+                    timeout: @idle_timeout
+        end
+      end
+    end
+  end
+end

data/lib/ultex/eos/hooks.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Peatio
+  module Eos
+    module Hooks
+      BLOCKCHAIN_VERSION_REQUIREMENT = "~> 1.0.0"
+      WALLET_VERSION_REQUIREMENT = "~> 1.0.0"
+
+      class << self
+        def check_compatibility
+          unless Gem::Requirement.new(BLOCKCHAIN_VERSION_REQUIREMENT)
+                                 .satisfied_by?(Gem::Version.new(Peatio::Blockchain::VERSION))
+            [
+              "Eos blockchain version requiremnt was not suttisfied by Peatio::Blockchain.",
+              "Eos blockchain requires #{BLOCKCHAIN_VERSION_REQUIREMENT}.",
+              "Peatio::Blockchain version is #{Peatio::Blockchain::VERSION}"
+            ].join('\n').tap {|s| Kernel.abort s }
+          end
+
+          unless Gem::Requirement.new(WALLET_VERSION_REQUIREMENT)
+                                 .satisfied_by?(Gem::Version.new(Peatio::Wallet::VERSION))
+            [
+              "Eos wallet version requiremnt was not suttisfied by Peatio::Wallet.",
+              "Eos wallet requires #{WALLET_VERSION_REQUIREMENT}.",
+              "Peatio::Wallet version is #{Peatio::Wallet::VERSION}"
+            ].join('\n').tap {|s| Kernel.abort s }
+          end
+        end
+
+        def register
+          Peatio::Blockchain.registry[:eos] = Eos::Blockchain.new
+          Peatio::Wallet.registry[:eos] = Eos::Wallet.new
+        end
+      end
+
+      if defined?(Rails::Railtie)
+        require "peatio/eos/railtie"
+      else
+        check_compatibility
+        register
+      end
+    end
+  end
+end

data/lib/ultex/eos/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Peatio
+  module Eos
+    class Railtie < Rails::Railtie
+      config.before_initialize do
+        Hooks.check_compatibility
+      end
+
+      config.after_initialize do
+        Hooks.register
+      end
+    end
+  end
+  end

data/lib/ultex/eos/transaction_serializer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Peatio
+  module Eos
+    class TransactionSerializer
+      class << self
+        def to_pack_json(address: "default", to_address: "default", amount: "default")
+          {
+            "code" => "eosio.token",
+            "action" => "transfer",
+            "args" => {
+              "from" => address,
+              "to" => to_address,
+              "quantity" => amount,
+              "memo" => "transfer from peatio"
+            }
+          }
+        end
+      end
+
+      class << self
+        def to_sign_json(ref_block_num: 2, block_prefix: 1, expiration: "default",
+                         address: "default", packed_data: "default", secret: "default", chain_id: "default")
+          [
+            {
+              "ref_block_num" => ref_block_num,
+              "ref_block_prefix" => block_prefix,
+              "max_cpu_usage_ms" => 0,
+              "max_net_usage_words" => 0,
+              "expiration" => expiration,
+              "region" => "0",
+              "actions" => [{
+                "account" => "eosio.token",
+                  "name" => "transfer",
+                  "authorization" => [{
+                    "actor" => address,
+                      "permission" => "active",
+                  }],
+                  "data" => packed_data,
+              }],
+                :signatures => []
+            },
+            [secret],
+            chain_id
+          ]
+        end
+      end
+
+      class << self
+        def to_push_json(address: "default", packed_data: "default", expiration: "default",
+                         block_num: 2, block_prefix: 1, signature: "default")
+          {
+            "compression" => "none",
+            "transaction" => {
+              "actions" => [{
+                "account" => "eosio.token",
+                "name" => "transfer",
+                "authorization" => [{
+                  "actor" => address,
+                  "permission" => "active"
+                }],
+                "data" =>  packed_data,
+              }],
+                "expiration" => expiration,
+                "max_cpu_usage_ms" => 0,
+                "max_net_usage_words" => 0,
+                "delay_sec" => 0,
+                "ref_block_num" => block_num,
+                "ref_block_prefix" => block_prefix,
+                "context_free_actions" => [],
+                "context_free_data" => [],
+                "signatures" => signature,
+                "transaction_extensions" => []
+            },
+            "signatures" => signature
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ultex/eos/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Peatio
+  module Eos
+    VERSION = "0.2.1"
+  end
+end

data/lib/ultex/eos/wallet.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Peatio
+  module Eos
+    class Wallet < Peatio::Wallet::Abstract
+      PRECISION = 4
+
+      ADDRESS_LENGTH = 12
+
+      TOKEN_STANDARD = "eosio.token"
+
+      class MissingTokenNameError < Peatio::Blockchain::Error; end
+
+      def initialize(settings={})
+        @settings = settings
+      end
+
+      def configure(settings={})
+        @settings.merge!(settings.slice(*SUPPORTED_SETTINGS))
+
+        @wallet = @settings.fetch(:wallet) do
+          raise Peatio::Wallet::MissingSettingError, :wallet
+        end.slice(:uri, :address, :secret)
+
+        @currency = @settings.fetch(:currency) do
+          raise Peatio::Wallet::MissingSettingError, :wallet
+        end.slice(:id, :base_factor, :options)
+        raise MissingTokenNameError if @currency.dig(:options, :eos_token_name).blank?
+      end
+
+      def create_address!(options={})
+        # For EOS and all others eosio.token deposits we use one EOS account which is defined like deposit wallet address in peatio.
+        # In Peatio EOS plugin we will define owner of deposit by user unige identifier (UID)
+        name = "#{@wallet.fetch(:address)}?memo=#{options.fetch(:uid)}"
+        {address: name, secret: @wallet.fetch(:secret)}
+      rescue Peatio::Eos::Client::Error => e
+        raise Peatio::Wallet::ClientError, e
+      end
+
+      def create_transaction!(transaction, _options={})
+        tx = transaction
+        amount = normalize_amount(tx.amount)
+        address = normalize_address(@wallet.fetch(:address))
+        # Pack main transaction info into hash
+        packed_data = client.json_rpc("/v1/chain/abi_json_to_bin", Peatio::Eos::TransactionSerializer.to_pack_json(address: address,
+                                     to_address: tx.to_address, amount: amount)).fetch("binargs")
+        info = client.json_rpc("/v1/chain/get_info")
+        # Get block info
+        block = client.json_rpc("/v1/chain/get_block", "block_num_or_id" => info.fetch("last_irreversible_block_num"))
+        ref_block_num = info.fetch("last_irreversible_block_num") & 0xFFFF
+        # Get transaction expiration
+        expiration = normalize_expiration(block.fetch("timestamp"))
+        # Sign transaction before push
+        signed = client.json_rpc("/v1/wallet/sign_transaction", Peatio::Eos::TransactionSerializer.to_sign_json(ref_block_num: ref_block_num,
+                                block_prefix: block.fetch("ref_block_prefix"), expiration: expiration, address: address,
+                                packed_data: packed_data, secret: @wallet.fetch(:secret), chain_id: info.fetch("chain_id")), 8900)
+        txid = client.json_rpc("/v1/chain/push_transaction", Peatio::Eos::TransactionSerializer.to_push_json(address: address,
+                              packed_data: packed_data, expiration: signed.fetch("expiration"), block_num: signed.fetch("ref_block_num"),
+                              block_prefix: signed.fetch("ref_block_prefix"), signature: signed.fetch("signatures"))).fetch("transaction_id")
+        tx.hash = txid
+        tx
+      rescue Peatio::Eos::Client::Error => e
+        raise Peatio::Wallet::ClientError, e
+      end
+
+      def load_balance!
+        balance = client.json_rpc("/v1/chain/get_currency_balance",
+                                  "account" => @wallet.fetch(:address), "code" => TOKEN_STANDARD)
+                        .find {|b| b.split[1] == @currency.dig(:options, :eos_token_name) }
+        balance.blank? ? 0 : normalize_balance(balance)
+      rescue Peatio::Eos::Client::Error => e
+        raise Peatio::Wallet::ClientError, e
+      end
+
+      private
+
+      def normalize_address(address)
+        address&.split('?memo=').first
+      end
+
+      def normalize_amount(amount)
+        "%.#{PRECISION}f" % amount + " #{@currency.dig(:options, :eos_token_name)}"
+      end
+
+      def normalize_balance(balance)
+        balance.chomp(@currency.dig(:options, :eos_token_name)).to_d
+      end
+
+      def normalize_expiration(time)
+        (Time.parse(time) + 3600).iso8601(6).split("+").first
+      end
+
+      def client
+        uri = @wallet.fetch(:uri) { raise Peatio::Wallet::MissingSettingError, :uri }
+        @client ||= Client.new(uri)
+      end
+    end
+  end
+end