moneymarket 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 431f681b6306e4f8f9bac8017b05eb444b8fdf2e
+  data.tar.gz: f27dfd43db2c3aa4eadb7e4f9e82f44760b35c1a
+SHA512:
+  metadata.gz: c889833e9447fb731530f530aa588668e2d0d399d5730c8febaa935e7f5d8374dc88c3af6b40fa537238ef34b51527833c61235d982b768957d39bd95b98cac1
+  data.tar.gz: 9b9ecb7169ef94c1bb361e3a3c86f0bb85c5e633029c2bb716176594ac1646066bab861326227dacd89b26b02d3c823ddbac4cde512737ff47c8ccb52417934d

data/bin/moneymarket

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# TOOD: json-RPC mode
+# require 'moneymarket'
+# require 'moneymarket/cli'

data/lib/moneymarket.rb

@@ -0,0 +1,20 @@
+require 'moneymarket/version'
+
+require 'money'
+require 'moneymarket/utils/calculator'
+require 'moneymarket/utils/command'
+
+require 'moneymarket/core/order'
+require 'moneymarket/core/bid'
+require 'moneymarket/core/ask'
+require 'moneymarket/core/market'
+require 'moneymarket/core/match'
+require 'moneymarket/core/account'
+require 'moneymarket/core/account_provider'
+require 'moneymarket/core/slope'
+require 'moneymarket/core/book'
+
+module Moneymarket
+  def self.book()
+  end
+end

data/lib/moneymarket/commands/check_order_solvent.rb

@@ -0,0 +1,12 @@
+class CheckOrderSolvent < Command.new(:market, :order)
+  def perform
+    return true if order.market_order?
+    source_available_amount >= order.required_amount
+  end
+
+  private
+
+  def source_available_amount
+    market.source_account_for(order).available
+  end
+end

data/lib/moneymarket/commands/execute_match.rb

@@ -0,0 +1,109 @@
+class ApplyMatch < Command.new(:market, :match)
+  def perform
+    cache_balances :before
+    execute_exchange
+    execute_fees unless same_user?
+    cache_balances :after
+    event
+  end
+
+  private
+
+  def execute_exchange
+    bid_quote_account.unfreeze quote unless bid.new?
+    ask_base_account.unfreeze volume unless ask.new?
+
+    bid.consume volume
+    ask.consume volume
+
+    transfer quote, from: bid_quote_account, to: ask_quote_account
+    transfer volume, from: ask_base_account, to: bid_base_account
+
+    event.quote = quote
+  end
+
+  def execute_fees
+    transfer bid_fee, from: bid_base_account, to: exchange_base_account
+    transfer ask_fee, from: ask_quote_account, to: exchange_quote_account
+
+    event.bid_fee = bid_fee
+    event.ask_fee = ask_fee
+  end
+
+  def cache_balances(_which)
+    event.public_send("bid_base_account_#{_which}=", bid_base_account.clone)
+    event.public_send("bid_quote_account_#{_which}=", bid_quote_account.clone)
+    event.public_send("ask_base_account_#{_which}=", ask_base_account.clone)
+    event.public_send("ask_quote_account_#{_which}=", ask_quote_account.clone)
+    event.public_send("ex_base_account_#{_which}=", exchange_base_account.clone)
+    event.public_send("ex_quote_account_#{_which}=", exchange_quote_account.clone)
+  end
+
+  def event
+    @event ||= Events::TransactionExecuted.new.tap do |ev|
+      ev.bid = bid.ref
+      ev.ask = ask.ref
+      ev.volume = volume
+      ev.quote = quote
+    end
+  end
+
+  def bid
+    match.bid
+  end
+
+  def ask
+    match.ask
+  end
+
+  def volume
+    match.volume
+  end
+
+  def quote
+    @quote ||= begin
+      CalculateQuote.new(volume: volume, unit_price: match.price_paid).perform
+    end
+  end
+
+  def transfer(_amount, from: nil, to: nil)
+    from.withdraw _amount
+    to.deposit _amount
+  end
+
+  def bid_base_account
+    market.base_account_for match.bid
+  end
+
+  def ask_base_account
+    market.base_account_for match.ask
+  end
+
+  def bid_quote_account
+    market.quote_account_for match.bid
+  end
+
+  def ask_quote_account
+    market.quote_account_for match.ask
+  end
+
+  def same_user?
+    bid.user == ask.user
+  end
+
+  def bid_fee
+    @bid_fee ||= CalculateFee.new(order: bid, collected_amount: volume).perform
+  end
+
+  def ask_fee
+    @ask_fee ||= CalculateFee.new(order: ask, collected_amount: quote).perform
+  end
+
+  def exchange_base_account
+    market.exchange_base_account
+  end
+
+  def exchange_quote_account
+    market.exchange_quote_account
+  end
+end

data/lib/moneymarket/commands/limit_matches.rb

@@ -0,0 +1,28 @@
+class LimitMatches < Command.new(:matches, :destination_limit)
+  def perform
+    matches.select do |match|
+      next false if destination_limit <= 0
+
+      quote = calc_quote(match)
+      if quote > destination_limit
+        # IDEA: instead of lowering the match amount maybe this should be considered insolvency
+        match.volume = calc_volume(match, destination_limit)
+        destination_limit = 0
+      else
+        destination_limit -= quote
+      end
+
+      match.volume > 0
+    end
+  end
+
+  private
+
+  def calc_quote(_match)
+    _match.match.destination_collected_amount for_volume: _match.volume
+  end
+
+  def calc_volume(_match, _new_quote)
+    _match.match.volume_required_to_collect _new_quote
+  end
+end

data/lib/moneymarket/commands/match_order_to_slope.rb

@@ -0,0 +1,32 @@
+class MatchOrderToSlope < Command.new(:slope, :order)
+  def perform
+    Enumerator.new do |y|
+      remaining = order.volume
+      each_order do |match|
+        next if match.timestamp > _order.timestamp # << this should trigger an alert, should never happen
+
+        if match.volume >= remaining
+          y << build_match(match, remaining)
+          break
+        else
+          y << build_match(match, match.volume)
+          remaining -= match.volume
+        end
+      end
+    end
+  end
+
+  private
+
+  def each_order
+    if order.market_order?
+      slope.each
+    else
+      slope.each_until_limit(order.limit)
+    end
+  end
+
+  def build_match(_match, _volume)
+    Match.new(trigger: order, match: _match, volume: _volume)
+  end
+end

data/lib/moneymarket/core/account.rb

@@ -0,0 +1,41 @@
+module Moneymarket
+  class Account
+    attr_reader :user, :currency, :total, :frozen, :ref
+
+    def initialize(_user, _currency, _total, _frozen, _ref = nil)
+      @user = _user
+      @currency = _currency
+      @total = _total
+      @frozen = _frozen
+      @ref = _ref
+    end
+
+    def available
+      total - frozen
+    end
+
+    def freeze(_amount)
+      # TODO: check currency?
+      raise ArgumentError, 'amount to freeze must be positive' if _amount < 0
+      raise ArgumentError, 'trying to freeze more than is available' if _amount > available
+      @frozen += _amount
+    end
+
+    def unfreeze(_amount)
+      raise ArgumentError, 'amount to unfreeze must be positive' if _amount < 0
+      raise ArgumentError, 'trying to unfreeze more than is frozen' if _amount > frozen
+      @frozen -= _amount
+    end
+
+    def deposit(_amount)
+      raise ArgumentError, 'amount to deposit must be positive' if _amount < 0
+      @total += _amount
+    end
+
+    def withdraw(_amount)
+      raise ArgumentError, 'amount to withdraw must be positive' if _amount < 0
+      raise ArgumentError, 'not enough funds to withdraw' if _amount > available
+      @total -= _amount
+    end
+  end
+end

data/lib/moneymarket/core/account_provider.rb

@@ -0,0 +1,34 @@
+module Moneymarket
+  class AccountProvider
+    def initialize
+      @accounts = {}
+    end
+
+    def reset
+      @accounts = {}
+    end
+
+    def exchange_account_for(_currency)
+      assert_implemented :exchange_account_for
+    end
+
+    def account_for(_user_id, _currency)
+      assert_implemented :account_for
+    end
+
+    def preload_user_balances(_users, _currencies)
+      assert_implemented :preload_user_balances
+    end
+
+    def preload_balances(_order)
+      _order.base_balance = fetch_balance(_order.account_id, _order.base_currency)
+      _order.quote_balance = fetch_balance(_order.account_id,  _order.quote_currency)
+    end
+
+    private
+
+    def assert_implemented(_name)
+      raise NotImplementedError, "#{_name} is not implemented"
+    end
+  end
+end

data/lib/moneymarket/core/ask.rb

@@ -0,0 +1,27 @@
+module Moneymarket
+  class Ask < Order
+    def bid?
+      false
+    end
+
+    def source_account
+      :base_account
+    end
+
+    def destination_account
+      :quote_account
+    end
+
+    def source_required_amount(for_volume: nil)
+      volume || amount
+    end
+
+    def destination_collected_amount(for_volume: nil)
+      Calculator.quote(volume: volume || amount, unit_price: limit)
+    end
+
+    def volume_required_to_collect(_source_amount)
+      _source_amount
+    end
+  end
+end

data/lib/moneymarket/core/bid.rb

@@ -0,0 +1,31 @@
+module Moneymarket
+  class Bid < Order
+    def bid?
+      true
+    end
+
+    def source_account
+      :quote_account
+    end
+
+    def destination_account
+      :base_account
+    end
+
+    def source_required_amount(for_volume: nil)
+      Calculator.quote(volume: for_volume || volume, unit_price: limit)
+    end
+
+    def destination_collected_amount(for_volume: nil)
+      for_volume || volume
+    end
+
+    def volume_required_to_collect(_source_amount)
+      Calculator.volume(
+        quote: _source_amount,
+        unit_price: limit,
+        unit_currency: volume.currency
+      )
+    end
+  end
+end

data/lib/moneymarket/core/book.rb

@@ -0,0 +1,76 @@
+module Moneymarket
+  def Book
+    attr_reader :asks, :bids
+
+    def initialize(_market)
+      @market = _market
+      @bids = Slope.new { |a, b| a.limit_cents <=> b.limit_cents }
+      @asks = Slope.new { |a, b| b.limit_cents <=> a.limit_cents }
+    end
+
+    def flush_events
+      flushed = @events
+      @events = []
+      flushed
+    end
+
+    def push(_order)
+      # TODO: check market(currency)
+
+      if _order.new?
+        raise ArgumentError, 'insolvent order' unless check_solvent _order
+
+        matches = match_to_slope _order
+        matches = adjust_market_order matches, _order if _order.market_order?
+        preload_balances matches
+        matches.each { |tx| execute_match tx }
+        _order.flag_as_open
+
+        freeze_source_balance _order
+        # TODO: execute_triggers (stop-loss, take-profit, etc)
+      end
+
+      slope_for(_order).add _order if _order.open?
+    end
+
+    def cancel(_order)
+      if _order.open?
+
+        slope_for(_order).remove _order
+      end
+    end
+
+    private
+
+    def slope_for(_order)
+      if order.bid? then bids else asks end
+    end
+
+    def oposite_slope(_order)
+      if order.bid? then asks else bids end
+    end
+
+    def check_solvent(_order)
+      CheckOrderSolvent.for market: market, order: _order
+    end
+
+    def match_to_slope(_order)
+      slope = oposite_slope(_order)
+      MatchOrderToSlope.for slope: slope, order: _order
+    end
+
+    def adjust_market_order(_matches, _order)
+      limit = market.source_account(_order).available_amount
+      LimitMatches.for matches: _matches, limit: limit
+    end
+
+    def execute_match(_match)
+      @events << ExecuteMatch.for(market: market, match: _match)
+    end
+
+    def preload_balances(_matches)
+      users = _matches.map { |m| [m.bid.user, m.ask.user] }.flatten.uniq
+      market.preload_user_balances users
+    end
+  end
+end

data/lib/moneymarket/core/market.rb

@@ -0,0 +1,39 @@
+module Moneymarket
+  class Market
+    attr_reader :account_provider
+
+    def initialize(_base_currency, _quote_currency, account_provider = nil)
+      @base_currency = _base_currency
+      @quote_currency = _quote_currency
+      @account_provider = account_provider
+    end
+
+    def preload_user_balances(_users)
+      account_provider.preload_balances(_users, [_base_currency, _quote_currency])
+    end
+
+    def exchange_base_account
+      account_provider.exchange_account_for base_currency
+    end
+
+    def exchange_quote_account
+      account_provider.exchange_account_for quote_currency
+    end
+
+    def base_account_for(_order)
+      account_provider.account_for(_order.user_id, base_currency)
+    end
+
+    def quote_account_for(_order)
+      account_provider.account_for(_order.user_id, quote_currency)
+    end
+
+    def source_account_for(_order)
+      public_send(_order.source_account, _order)
+    end
+
+    def destination_account_for(_order)
+      public_send(_order.destination_account, _order)
+    end
+  end
+end

data/lib/moneymarket/core/match.rb

@@ -0,0 +1,18 @@
+module Moneymarket
+  class Match
+    attr_reader :market, :bid, :ask
+    attr_accessor :volume
+
+    def initialize(_trigger, _match, _volume)
+      @trigger = _trigger
+      @bid = _trigger.bid? ? _trigger : _match
+      @ask = _trigger.bid? ? _match : _trigger
+      @match = _match
+      @volume = _volume
+    end
+
+    def price_paid
+      match.limit
+    end
+  end
+end

data/lib/moneymarket/core/order.rb

@@ -0,0 +1,60 @@
+module Moneymarket
+  class Order
+    NEW = :new
+    OPEN = :open
+    TRADED = :traded
+    CANCELED = :canceled
+
+    attr_reader :user, :volume, :limit, :fee, :ref
+
+    def initialize(user: nil, status: NEW, volume: nil, limit: nil, fee: 0.0, ref: nil)
+      @user = user
+      @status = status
+      @volume = volume
+      @limit = limit
+      @fee = fee
+      @ref = ref
+    end
+
+    def market_order?
+      limit.nil?
+    end
+
+    def base_currency
+      volume.currency
+    end
+
+    def quote_currency
+      limit.currency
+    end
+
+    def consume(_volume)
+      raise ArgumentError, 'cannot consume, order closed' if closed?
+      raise ArgumentError, 'amount to consume must be positive' if _volume < 0
+      raise ArgumentError, 'trying to consume more than is available' if _volume > @volume
+      @volume -= _volume
+
+      @status = TRADED if @volume == 0
+    end
+
+    def flag_as_open
+      if market_order?
+        flag_as_canceled
+      else
+        @status = OPEN if new?
+      end
+    end
+
+    def flag_as_canceled
+      @status = CANCELED unless closed?
+    end
+
+    [NEW, OPEN, TRADED, CANCELED].each do |name|
+      define_method("#{name}?") { @status == name }
+    end
+
+    def closed?
+      traded? || canceled?
+    end
+  end
+end

data/lib/moneymarket/core/slope.rb

@@ -0,0 +1,44 @@
+module Moneymarket
+  class Slope
+    def initialize(&_comp_func)
+      @orders = []
+      @cmp = _comp_func
+    end
+
+    def add(_order)
+      idx = orders.index { |o| compare(o, _order) > 0 }
+      if idx.nil?
+        orders << _order
+      else
+        orders.insert idx, _order
+      end
+    end
+
+    def remove(_order)
+      orders.delete(_order)
+    end
+
+    def each
+      orders.each
+    end
+
+    def each_until_limit(_limit)
+      Enumerator.new do |y|
+        orders.each do |order|
+          break if cmp.call(order, _limit) > 0
+          y << order
+        end
+      end
+    end
+
+    private
+
+    attr_reader :orders, :cmp
+
+    def compare(a, b)
+      r = cmp.call a, b
+      r = a.created_at <=> b.created_at if r == 0
+      r
+    end
+  end
+end

data/lib/moneymarket/utils/calculator.rb

@@ -0,0 +1,27 @@
+module Moneymarket
+  module Calculator
+    extend self
+
+    def quote(volume: nil, unit_price: nil)
+      base_currency = volume.currency
+      quote = ((unit_price.cents * volume.cents).to_d / base_currency.subunit_to_unit).ceil
+      Money.new quote, unit_price.currency
+    end
+
+    def volume(quote: nil, unit_price: nil, unit_currency: nil)
+      volume = ((quote.cents * unit_currency.subunit_to_unit).to_d / unit_price.cents).floor
+      Money.new volume, unit_currency
+    end
+
+    def fee(amount: nil, percent: nil)
+      result = (amount.cents * (percent.to_d / 100)).floor # fees always round to floor
+      Money.new result, amount.currency
+    end
+
+    def order_fee(order: nil, collected_amount: nil) # move this to command
+      collected_amount = order.collected_amount if collected_amount.nil?
+      fee_cents = (collected_amount.cents * (order.fee.to_d / 100)).floor
+      Money.new fee_cents, collected_amount.currency
+    end
+  end
+end

data/lib/moneymarket/utils/command.rb

@@ -0,0 +1,27 @@
+module Moneymarket
+  module Command
+    def self.new(*_attributes)
+      attr_names = []
+      attr_defaults = {}
+
+      _attributes.each do |att|
+        if att.is_a? Hash
+          attr_defaults.merge att
+          attr_names += att.keys
+        else
+          attr_names << att
+        end
+      end
+
+      Struct.new(*attr_names) do
+        define_method(:initialize) do |kwargs={}|
+          kwargs = attr_defaults.merge kwargs
+          attr_values = attr_names.map { |a| kwargs[a] }
+          super(*attr_values)
+        end
+
+        define_method(:perform) {}
+      end
+    end
+  end
+end

data/lib/moneymarket/version.rb

@@ -0,0 +1,3 @@
+module Trader
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,238 @@
+--- !ruby/object:Gem::Specification
+name: moneymarket
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ignacio Baixas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '6.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '6.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-nc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.5'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: pry-remote
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Yep
+email:
+- ignacio@platan.us
+executables:
+- moneymarket
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/moneymarket
+- lib/moneymarket.rb
+- lib/moneymarket/commands/check_order_solvent.rb
+- lib/moneymarket/commands/execute_match.rb
+- lib/moneymarket/commands/limit_matches.rb
+- lib/moneymarket/commands/match_order_to_slope.rb
+- lib/moneymarket/core/account.rb
+- lib/moneymarket/core/account_provider.rb
+- lib/moneymarket/core/ask.rb
+- lib/moneymarket/core/bid.rb
+- lib/moneymarket/core/book.rb
+- lib/moneymarket/core/market.rb
+- lib/moneymarket/core/match.rb
+- lib/moneymarket/core/order.rb
+- lib/moneymarket/core/slope.rb
+- lib/moneymarket/utils/calculator.rb
+- lib/moneymarket/utils/command.rb
+- lib/moneymarket/version.rb
+homepage: https://github.com/surbtc/moneymarket
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.1
+signing_key: 
+specification_version: 4
+summary: Moneymarket is a lightweight in-memory foreign exchange market engine
+test_files: []
+has_rdoc: