waves_ruby_client 0.1.0

data/lib/sign/int32.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# simulate 32 bit integer with overflow
+class Int32
+  attr_accessor :val
+  def initialize(val)
+    self.val = if val.is_a?(Int32)
+                 val.val
+               else
+                 val
+               end
+  end
+
+  def ==(other)
+    to_i == if other.is_a?(Int32)
+              other.to_i
+            else
+              other
+            end
+  end
+
+  def self.force_overflow_signed(i)
+    force_overflow_unsigned(i + 2**31) - 2**31
+  end
+
+  def self.force_overflow_unsigned(i)
+    i % 2**32 # or equivalently: i & 0xffffffff
+  end
+
+  def r_shift_pos(other)
+    other_val = other.is_a?(Int32) ? other.val : other
+    Int32.new(self.class.force_overflow_unsigned(val) >> other_val)
+  end
+
+  def to_i
+    self.class.force_overflow_signed(val)
+  end
+
+  def dup
+    Int32.new(val)
+  end
+
+  ['|', '^', '+', '-', '&', '*'].each do |op|
+    define_method op do |other|
+      if other.is_a?(Int32)
+        Int32.new(to_i.send(op, other.to_i))
+      else
+        super(other)
+      end
+    end
+  end
+
+  private
+
+  def respond_to_missing?(meth, _include_private = false)
+    val.respond_to?(meth)
+  end
+
+  def method_missing(meth, *args, &block)
+    return super unless respond_to_missing?(meth)
+    Int32.new(self.class.force_overflow_signed(val.send(meth, *args, &block)))
+  end
+end

data/lib/waves_ruby_client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_support/core_ext/object/instance_variables'
+require 'active_support/duration'
+require 'active_support/core_ext/numeric'
+require 'httparty'
+require 'singleton'
+
+require 'sign/int32'
+require 'sign/axlsign'
+
+require 'btc/data'
+require 'btc/base58'
+
+require 'waves_ruby_client/version'
+require 'waves_ruby_client/asset'
+require 'waves_ruby_client/conversion'
+require 'waves_ruby_client/api'
+require 'waves_ruby_client/order_book'
+require 'waves_ruby_client/order_data/place'
+require 'waves_ruby_client/order_data/cancel'
+require 'waves_ruby_client/order_data/user_orders'
+require 'waves_ruby_client/order'
+require 'waves_ruby_client/wallet'
+require 'waves_ruby_client/transaction'
+
+module WavesRubyClient
+  WAVES_PUBLIC_KEY = ENV['WAVES_PUBLIC_KEY']
+  WAVES_PRIVATE_KEY = ENV['WAVES_PRIVATE_KEY']
+  WAVES_ADDRESS = ENV['WAVES_ADDRESS']
+  API_URL = ENV['WAVES_API_URL'] || 'https://nodes.wavesnodes.com'
+  MATCHER_PUBLIC_KEY = ENV['WAVES_MATCHER_PUBLIC_KEY'] ||
+                       '7kPFrHDiGw1rCm7LPszuECwWYL3dMf6iMifLRDJQZMzy'
+
+  BTC_ASSET_ID = '8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS'
+  WAVES_ASSET_ID = 'WAVES'
+
+  MATCHER_FEE = 0.003
+  NUMBER_MULTIPLIKATOR = 10**8
+
+  PRICE_ASSET = WavesRubyClient::Asset.btc
+  AMOUNT_ASSET = WavesRubyClient::Asset.waves
+
+  OrderAlreadyFilled = Class.new(StandardError)
+
+  # try method call several times
+  def self.try_many_times(times = 5)
+    tries ||= times
+    yield
+  rescue StandardError => e
+    sleep(5)
+    retry unless (tries -= 1).zero?
+    raise e
+  end
+end

data/lib/waves_ruby_client/api.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WavesRubyClient
+  # Access to waves api
+  class Api
+    include Singleton
+
+    def call_matcher(path, method = :get, args = {})
+      WavesRubyClient.try_many_times do
+        call('/matcher' + path, method, args)
+      end
+    end
+
+    def call(path, method = :get, args = {})
+      response = HTTParty.send(method, WavesRubyClient::API_URL + path, args)
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/waves_ruby_client/asset.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module WavesRubyClient
+  class Asset
+    include ActiveModel::Model
+    attr_accessor :name, :id, :url_id
+
+    def self.waves
+      new(name: 'WAVES', id: '', url_id: WavesRubyClient::WAVES_ASSET_ID)
+    end
+
+    def self.btc
+      new(name: 'BTC', id: WavesRubyClient::BTC_ASSET_ID,
+          url_id: WavesRubyClient::BTC_ASSET_ID)
+    end
+
+    def to_bytes
+      if name == WavesRubyClient::WAVES_ASSET_ID
+        [0]
+      else
+        [1].concat(WavesRubyClient::Conversion.base58_to_bytes(id))
+      end
+    end
+  end
+end

data/lib/waves_ruby_client/conversion.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module WavesRubyClient
+  # Conversion Helpers
+  module Conversion
+    module ClassMethods # :nodoc:
+      def long_to_bytes(long)
+        long = long.to_i
+        bytes = []
+        8.times do
+          bytes << (long & 255)
+          long /= 256
+        end
+        bytes.reverse
+      end
+
+      def bytes_to_base58(bytes)
+        BTC::Base58.base58_from_data(bytes.map(&:chr).join)
+      end
+
+      def base58_to_bytes(input)
+        BTC::Base58.data_from_base58(input).bytes
+      end
+    end
+
+    extend ClassMethods
+    include ClassMethods
+  end
+end

data/lib/waves_ruby_client/order.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module WavesRubyClient
+  # A limit order
+  class Order
+    include ActiveModel::Model
+
+    JSON_HEADERS = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }.freeze
+
+    attr_accessor :type, :amount, :id, :timestamp, :status, :price
+    attr_writer :filled
+
+    # get all orders for WAVES_PUBLIC_KEY
+    def self.all
+      url = ['/orderbook', WavesRubyClient::AMOUNT_ASSET.url_id,
+             WavesRubyClient::PRICE_ASSET.url_id,
+             'publicKey', WavesRubyClient::WAVES_PUBLIC_KEY].join('/')
+      data = WavesRubyClient::OrderData::UserOrders.new.data_with_signature
+      orders = WavesRubyClient::Api.instance.call_matcher(url, :get, headers: data)
+      orders.map do |order_hash|
+        attributes = %i[filled price amount].map do |attribute|
+          { attribute => order_hash[attribute.to_s].to_f / WavesRubyClient::NUMBER_MULTIPLIKATOR }
+        end.reduce({}, :merge)
+        new(order_hash.slice('id', 'status', 'type', 'timestamp').merge(attributes))
+      end
+    end
+
+    # get all orders waiting to be filled for WAVES_PUBLIC_KEY
+    def self.active
+      all.select { |o| o.status == 'Accepted' || o.status == 'PartiallyFilled' }
+    end
+
+    # order is waiting to be filled
+    def pending?
+      status != 'Filled' && status != 'PartiallyFilled'
+    end
+
+    # filled amount
+    def filled
+      refresh_from_collection
+      @filled
+    end
+
+    # place order
+    # any error is raised
+    def place
+      data = WavesRubyClient::OrderData::Place.new(self).data_with_signature
+      res = WavesRubyClient::Api.instance.call_matcher('/orderbook', :post,
+                                                       body: data.to_json,
+                                                       headers: JSON_HEADERS)
+      raise res.to_s unless res['status'] == 'OrderAccepted'
+      self.id = res['message']['id']
+      self
+    end
+
+    # cancel order
+    # any error is raised
+    def cancel
+      res = remove('cancel')
+      raise WavesRubyClient::OrderAlreadyFilled if res['message']&.match?(/Order is already Filled/)
+      raise res.to_s unless res['status'] == 'OrderCanceled'
+    end
+
+    # delete order after it has been cancelled
+    # any error is raised
+    def delete
+      res = remove('delete')
+      raise res.to_s unless res['status'] == 'OrderDeleted'
+    end
+
+    def price_asset
+      WavesRubyClient::PRICE_ASSET
+    end
+
+    def amount_asset
+      WavesRubyClient::AMOUNT_ASSET
+    end
+
+    # query order status
+    def refresh_status
+      url = "/orderbook/#{amount_asset.url_id}/#{price_asset.url_id}/#{id}"
+      response = WavesRubyClient::Api.instance.call_matcher(url, :get)
+      self.status = response['status']
+    end
+
+    private
+
+    # There is no api method to query data of a single order
+    # So all orders are retrieved
+    def refresh_from_collection
+      order = self.class.all.select { |o| o.id == id }.first
+      return unless order
+      assign_attributes(order.instance_values)
+    end
+
+    def remove(action)
+      data = WavesRubyClient::OrderData::Cancel.new(self).data_with_signature
+      url = "/orderbook/#{amount_asset.url_id}/#{price_asset.url_id}/#{action}"
+      WavesRubyClient::Api.instance.call_matcher(url, :post,
+                                                 body: data.to_json,
+                                                 headers: JSON_HEADERS)
+    end
+  end
+end

data/lib/waves_ruby_client/order_book.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module WavesRubyClient
+  # Orderbook for a pair of assets
+  class OrderBook
+    def self.btc_waves
+      new(WavesRubyClient::Asset.waves, WavesRubyClient::Asset.btc)
+    end
+
+    attr_accessor :asset1, :asset2, :bids, :asks
+
+    def initialize(asset1, asset2)
+      self.asset1 = asset1
+      self.asset2 = asset2
+      self.bids = self.asks = []
+    end
+
+    def refresh
+      order_book = WavesRubyClient::Api.instance.call_matcher(
+        "/orderbook/#{asset1.url_id}/#{asset2.url_id}"
+      )
+      self.asks = order_book['asks'].map { |order| scale(order) }
+      self.bids = order_book['bids'].map { |order| scale(order) }
+    end
+
+    private
+
+    def scale(order)
+      { price: order['price'].to_f / WavesRubyClient::NUMBER_MULTIPLIKATOR,
+        amount: order['amount'].to_f / WavesRubyClient::NUMBER_MULTIPLIKATOR }
+    end
+  end
+end

data/lib/waves_ruby_client/order_data/cancel.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module WavesRubyClient
+  module OrderData
+    # Data for cancelling an order
+    class Cancel
+      include WavesRubyClient::Conversion
+
+      attr_accessor :order
+
+      def initialize(order)
+        self.order = order
+      end
+
+      def data_with_signature
+        { sender: WavesRubyClient::WAVES_PUBLIC_KEY,
+          orderId: order.id,
+          signature: signature }
+      end
+
+      private
+
+      def signature
+        sign_bytes = Axlsign.sign(
+          base58_to_bytes(WavesRubyClient::WAVES_PRIVATE_KEY),
+          bytes_to_sign
+        )
+        bytes_to_base58(sign_bytes)
+      end
+
+      def bytes_to_sign
+        base58_to_bytes(WavesRubyClient::WAVES_PUBLIC_KEY) + base58_to_bytes(order.id)
+      end
+    end
+  end
+end

data/lib/waves_ruby_client/order_data/place.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module WavesRubyClient
+  module OrderData
+    # Data for placing an order
+    class Place
+      include WavesRubyClient::Conversion
+
+      attr_accessor :order
+
+      def initialize(order)
+        self.order = order
+      end
+
+      def data_with_signature
+        data.merge(signature: signature)
+      end
+
+      private
+
+      def signature
+        sign_bytes = Axlsign.sign(
+          base58_to_bytes(WavesRubyClient::WAVES_PRIVATE_KEY),
+          bytes_to_sign
+        )
+        bytes_to_base58(sign_bytes)
+      end
+
+      def expiration
+        @expiration ||= 1.day.since.to_i * 1000
+      end
+
+      def timestamp
+        @timestamp ||= Time.now.to_i * 1000
+      end
+
+      def data
+        { orderType: order.type,
+          assetPair: { amountAsset: order.amount_asset.id, priceAsset: order.price_asset.id },
+          price: (order.price * WavesRubyClient::NUMBER_MULTIPLIKATOR).to_i,
+          amount: (order.amount * WavesRubyClient::NUMBER_MULTIPLIKATOR).to_i,
+          timestamp: timestamp,
+          expiration: expiration,
+          matcherFee: WavesRubyClient::MATCHER_FEE * WavesRubyClient::NUMBER_MULTIPLIKATOR,
+          matcherPublicKey: WavesRubyClient::MATCHER_PUBLIC_KEY,
+          senderPublicKey: WavesRubyClient::WAVES_PUBLIC_KEY }
+      end
+
+      def bytes_to_sign
+        order_data = data
+        [
+          base58_to_bytes(order_data[:senderPublicKey]),
+          base58_to_bytes(order_data[:matcherPublicKey]),
+          order.amount_asset.to_bytes,
+          order.price_asset.to_bytes,
+          order.type == :buy ? 0 : 1,
+          long_to_bytes(order_data[:price]),
+          long_to_bytes(order_data[:amount]),
+          long_to_bytes(timestamp),
+          long_to_bytes(order_data[:expiration]),
+          long_to_bytes(order_data[:matcherFee])
+        ].flatten
+      end
+    end
+  end
+end

data/lib/waves_ruby_client/order_data/user_orders.rb

@@ -0,0 +1,34 @@
+
+# frozen_string_literal: true
+
+module WavesRubyClient
+  module OrderData
+    # Data for querying user orders
+    class UserOrders
+      include WavesRubyClient::Conversion
+
+      def data_with_signature
+        { Timestamp: timestamp.to_s,
+          Signature: signature }
+      end
+
+      private
+
+      def signature
+        sign_bytes = Axlsign.sign(
+          base58_to_bytes(WavesRubyClient::WAVES_PRIVATE_KEY),
+          bytes_to_sign
+        )
+        bytes_to_base58(sign_bytes)
+      end
+
+      def timestamp
+        @timestamp ||= Time.now.to_i * 1000
+      end
+
+      def bytes_to_sign
+        base58_to_bytes(WavesRubyClient::WAVES_PUBLIC_KEY) + long_to_bytes(timestamp)
+      end
+    end
+  end
+end