melaya 0.1.0

data/lib/melaya/strategies.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Melaya
+  # Strategies API — launch, control, and inspect trading strategies.
+  #
+  # A strategy is a server-managed runner (the Trading Engine, or an Agentic
+  # Trading Crew) that trades a universe on a cadence with server-side SL/TP
+  # and safety rails. Launch in paper mode (dry_run: true) or live
+  # (dry_run: false, which requires a connected exchange key).
+  #
+  # Maps to https://api.melaya.org/api/v1/strategies/* on the private plane.
+  class StrategiesAPI
+    def initialize(http)
+      @http = http
+    end
+
+    # Every strategy you own (running, paused, paper, and live).
+    def list
+      @http.get("/api/v1/strategies/list")["strategies"]
+    end
+
+    # A single strategy by id.
+    # @param strategy_id [String]
+    def get(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}")["strategy"]
+    end
+
+    # Launch a strategy. Pass dry_run: true for paper; live needs api_key_id.
+    # Returns the full response hash (includes "strategyId").
+    #
+    # @param name [String]
+    # @param strategy_type [String] e.g. "custom"
+    # @param exchange [String]
+    # @param market [String, nil]
+    # @param symbol [String, nil]
+    # @param api_key_id [String, nil]
+    # @param params [Hash, nil]
+    # @param runtime_mode [String, nil]
+    # @param dry_run [Boolean]
+    # @param key_bindings [Hash, nil]
+    def create(name:, strategy_type:, exchange:, market: nil, symbol: nil,
+               api_key_id: nil, params: nil, runtime_mode: nil, dry_run: true,
+               key_bindings: nil)
+      body = {
+        "name"         => name,
+        "strategyType" => strategy_type,
+        "exchange"     => exchange,
+        "market"       => market,
+        "symbol"       => symbol,
+        "apiKeyId"     => api_key_id,
+        "params"       => params,
+        "runtimeMode"  => runtime_mode,
+        "dryRun"       => dry_run,
+        "keyBindings"  => key_bindings,
+      }.reject { |_, v| v.nil? }
+      @http.post("/api/v1/strategies", body)
+    end
+
+    # Pause a running strategy (stops entering new cycles until resumed).
+    def pause(strategy_id)
+      @http.post("/api/v1/strategies/#{strategy_id}/pause")
+    end
+
+    # Resume a paused strategy.
+    def resume(strategy_id)
+      @http.post("/api/v1/strategies/#{strategy_id}/resume")
+    end
+
+    # Stop a strategy and tear down its runner. Cancels any in-flight approvals.
+    def stop(strategy_id)
+      @http.post("/api/v1/strategies/#{strategy_id}/stop")
+    end
+
+    # Soft-delete a strategy.
+    def delete(strategy_id)
+      @http.delete("/api/v1/strategies/#{strategy_id}")
+    end
+
+    # Update a running strategy's params (e.g. universe, cadence, risk caps).
+    # @param strategy_id [String]
+    # @param params [Hash]
+    def update_params(strategy_id, params)
+      @http.post("/api/v1/strategies/#{strategy_id}/update-params", params)
+    end
+
+    # Live runtime status of a strategy's runner (container health, tick count).
+    def status(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}/status")
+    end
+
+    # Performance series for a strategy (equity, PnL over time).
+    def performance(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}/performance")["rows"]
+    end
+
+    # Execution (order) rows for a strategy.
+    def executions(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}/executions")["rows"]
+    end
+
+    # Trade (fill) rows for a strategy.
+    def trades(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}/trades")["rows"]
+    end
+
+    # Log rows for a strategy (cycle markers, persona messages, errors).
+    def logs(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}/logs")["rows"]
+    end
+
+    # ── AI parameter optimizer ────────────────────────────────────────────────
+
+    # Kick off an AI-driven parameter optimization.
+    # +param_bounds+ maps each param name to a [min, max] array.
+    # +objective+ defaults to "sharpe"; +max_iterations+ is clamped to 1-20.
+    # Returns a hash including "runId".
+    #
+    # @param strategy_id [String]
+    # @param param_bounds [Hash] e.g. { "qty" => [0.001, 0.1] }
+    # @param objective [String]
+    # @param max_iterations [Integer]
+    # @param require_approval [Boolean, nil]
+    def ai_opt_start(strategy_id, param_bounds:, objective: "sharpe",
+                     max_iterations: 3, require_approval: nil)
+      body = {
+        "paramBounds"     => param_bounds,
+        "objective"       => objective,
+        "maxIterations"   => max_iterations,
+      }
+      body["requireApproval"] = require_approval unless require_approval.nil?
+      @http.post("/api/v1/strategies/#{strategy_id}/ai-opt/start", body)
+    end
+
+    # Current optimization status for a strategy.
+    def ai_opt_status(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}/ai-opt/status")
+    end
+
+    # Approve and apply the optimizer's proposed params to the running strategy.
+    # @param body [Hash] optional extra params
+    def ai_opt_approve(strategy_id, body = {})
+      @http.post("/api/v1/strategies/#{strategy_id}/ai-opt/approve", body)
+    end
+
+    # Stop an in-progress optimization.
+    def ai_opt_stop(strategy_id)
+      @http.post("/api/v1/strategies/#{strategy_id}/ai-opt/stop")
+    end
+
+    # Past optimization runs for a strategy.
+    def ai_opt_runs(strategy_id)
+      @http.get("/api/v1/strategies/#{strategy_id}/ai-opt/runs")
+    end
+  end
+end

data/lib/melaya/stream.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require "socket"
+require "openssl"
+require "uri"
+require "base64"
+require "digest"
+require "json"
+require "securerandom"
+
+require_relative "errors"
+
+module Melaya
+  # A minimal RFC 6455 WebSocket client built on stdlib TCP+TLS.
+  # No external gem required. Supports text frames; yields parsed JSON frames.
+  #
+  # Usage (block form — closes automatically):
+  #   MelayaWebSocket.connect(url, verify_ssl: true) do |ws|
+  #     ws.each_frame { |frame| puts frame.inspect; break }
+  #   end
+  #
+  # Usage (manual):
+  #   ws = MelayaWebSocket.new(url, verify_ssl: true)
+  #   ws.connect
+  #   ws.each_frame { |f| ... }
+  #   ws.close
+  class MelayaWebSocket
+    GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+    def self.connect(url, verify_ssl: true, &block)
+      ws = new(url, verify_ssl: verify_ssl)
+      ws.connect
+      if block_given?
+        begin
+          block.call(ws)
+        ensure
+          ws.close
+        end
+      else
+        ws
+      end
+    end
+
+    def initialize(url, verify_ssl: true)
+      @uri        = URI.parse(url)
+      @verify_ssl = verify_ssl
+      @socket     = nil
+      @closed     = false
+      @buf        = String.new("", encoding: "BINARY")
+    end
+
+    def connect
+      tcp = TCPSocket.new(@uri.host, @uri.port)
+
+      @socket = if @uri.scheme == "wss"
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.verify_mode = @verify_ssl ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        ssl = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
+        ssl.hostname = @uri.host
+        ssl.connect
+        ssl
+      else
+        tcp
+      end
+
+      handshake
+      self
+    end
+
+    # Iterate over incoming JSON frames. Yields each parsed frame Hash.
+    # Blocks until the socket closes or the block calls +break+.
+    def each_frame
+      loop do
+        frame = read_frame
+        break if frame.nil? # connection closed
+
+        next if frame.empty? # ping/pong or non-text
+
+        begin
+          yield JSON.parse(frame)
+        rescue JSON::ParserError
+          next # ignore non-JSON keep-alive text
+        end
+      end
+    rescue IOError, Errno::ECONNRESET, EOFError
+      # socket closed by remote
+    ensure
+      close
+    end
+
+    def close
+      return if @closed
+      @closed = true
+      begin
+        # Send a close frame (opcode 0x8) with no body, masked
+        send_frame(0x8, "")
+      rescue StandardError
+        # best-effort
+      ensure
+        @socket&.close rescue nil
+      end
+    end
+
+    private
+
+    def handshake
+      key    = Base64.strict_encode64(SecureRandom.bytes(16))
+      path   = @uri.request_uri
+      host   = @uri.host + (@uri.port && ![80, 443].include?(@uri.port) ? ":#{@uri.port}" : "")
+
+      request = [
+        "GET #{path} HTTP/1.1",
+        "Host: #{host}",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        "Sec-WebSocket-Key: #{key}",
+        "Sec-WebSocket-Version: 13",
+        "\r\n",
+      ].join("\r\n")
+
+      @socket.write(request)
+
+      # Read response headers
+      response = String.new("", encoding: "BINARY")
+      loop do
+        line = @socket.readline
+        response << line
+        break if line == "\r\n"
+      end
+
+      unless response.include?("101")
+        raise MelayaError.new("WebSocket handshake failed: #{response.lines.first.strip}", status: 0)
+      end
+
+      expected = Base64.strict_encode64(Digest::SHA1.digest("#{key}#{GUID}"))
+      unless response.include?(expected)
+        raise MelayaError.new("WebSocket Sec-WebSocket-Accept mismatch", status: 0)
+      end
+    end
+
+    # Read one complete WebSocket frame. Returns the payload string (text) or nil on close.
+    # Skips ping frames (sends pong) and continuation frames (not used by Melaya).
+    def read_frame
+      loop do
+        # Need at least 2 bytes for header
+        fill_buf(2)
+        b0 = @buf.getbyte(0)
+        b1 = @buf.getbyte(1)
+        @buf = @buf[2..]
+
+        # fin     = (b0 & 0x80) != 0  # we accept single-frame messages
+        opcode  = b0 & 0x0F
+        masked  = (b1 & 0x80) != 0
+        len     = b1 & 0x7F
+
+        len = case len
+              when 126
+                fill_buf(2)
+                v = @buf[0, 2].unpack1("n")
+                @buf = @buf[2..]
+                v
+              when 127
+                fill_buf(8)
+                v = @buf[0, 8].unpack1("Q>")
+                @buf = @buf[8..]
+                v
+              else
+                len
+              end
+
+        mask_key = nil
+        if masked
+          fill_buf(4)
+          mask_key = @buf[0, 4]
+          @buf = @buf[4..]
+        end
+
+        fill_buf(len)
+        payload = @buf[0, len].dup
+        @buf = @buf[len..]
+
+        if masked && mask_key
+          payload.bytes.each_with_index { |b, i| payload.setbyte(i, b ^ mask_key.getbyte(i % 4)) }
+        end
+
+        case opcode
+        when 0x1  # text
+          return payload.force_encoding("UTF-8")
+        when 0x2  # binary — treat as text (Melaya sends JSON)
+          return payload.force_encoding("UTF-8")
+        when 0x8  # close
+          return nil
+        when 0x9  # ping — send pong
+          send_frame(0xA, payload)
+          next
+        when 0xA  # pong
+          next
+        else
+          next # ignore unknown opcodes
+        end
+      end
+    end
+
+    # Ensure @buf has at least +n+ bytes.
+    def fill_buf(n)
+      while @buf.bytesize < n
+        chunk = @socket.read(n - @buf.bytesize)
+        raise EOFError, "connection closed" if chunk.nil? || chunk.empty?
+        @buf = @buf + chunk
+      end
+    end
+
+    # Send a WebSocket frame with masking (client->server MUST be masked).
+    def send_frame(opcode, payload)
+      payload = payload.dup.force_encoding("BINARY")
+      len     = payload.bytesize
+
+      header = String.new("", encoding: "BINARY")
+      header << (0x80 | opcode).chr(Encoding::BINARY)
+
+      mask_flag = 0x80 # clients must mask
+      if len <= 125
+        header << (mask_flag | len).chr(Encoding::BINARY)
+      elsif len <= 65535
+        header << (mask_flag | 126).chr(Encoding::BINARY)
+        header << [len].pack("n")
+      else
+        header << (mask_flag | 127).chr(Encoding::BINARY)
+        header << [len].pack("Q>")
+      end
+
+      mask_key = SecureRandom.bytes(4)
+      header << mask_key
+
+      masked_payload = payload.bytes.each_with_index.map { |b, i| b ^ mask_key.getbyte(i % 4) }.pack("C*")
+
+      @socket.write(header + masked_payload)
+    end
+  end
+
+  # WebSocket streaming API.
+  #
+  # Each method yields parsed JSON frame hashes to a block, or returns an
+  # Enumerator if no block is given. The connection is closed when the block
+  # returns or the Enumerator is exhausted.
+  #
+  # Public stream example:
+  #   melaya.stream.ticker(exchange: "binance", symbol: "BTC/USDT", market: "spot") do |frame|
+  #     puts frame["last"]
+  #     break   # close after first frame
+  #   end
+  #
+  # Private stream example (ticket minted automatically):
+  #   melaya.stream.strategies do |ev|
+  #     puts ev["type"], ev["strategyId"]
+  #     break
+  #   end
+  class StreamAPI
+    DEFAULT_WS_URL = "wss://wss.melaya.org"
+
+    def initialize(api_key, ws_url, http, verify_ssl: true)
+      @api_key    = api_key
+      @ws_url     = ws_url.to_s.chomp("/")
+      @http       = http
+      @verify_ssl = verify_ssl
+    end
+
+    # Live ticker frames.
+    def ticker(exchange:, symbol:, market: nil, &block)
+      open_public("/ws/ticker", compact(exchange: exchange, symbol: symbol, market: market), &block)
+    end
+
+    # Live order-book frames.
+    def orderbook(exchange:, symbol:, limit: nil, market: nil, &block)
+      open_public("/ws/orderbook", compact(exchange: exchange, symbol: symbol, limit: limit, market: market), &block)
+    end
+
+    # Live OHLCV candle frames.
+    def ohlcv(exchange:, symbol:, timeframe:, market: nil, &block)
+      open_public("/ws/ohlcv", compact(exchange: exchange, symbol: symbol, timeframe: timeframe, market: market), &block)
+    end
+
+    # Live public-trade frames.
+    def trades(exchange:, symbol:, market: nil, &block)
+      open_public("/ws/public-trades", compact(exchange: exchange, symbol: symbol, market: market), &block)
+    end
+
+    # Cross-exchange liquidation firehose. Omit +exchange+ for all venues.
+    def liquidations(exchange: nil, &block)
+      open_public("/ws/liquidations", compact(exchange: exchange), &block)
+    end
+
+    # Live strategy events for your account (cycle markers, agent messages,
+    # approval requests, executions, status). Mints a ticket, opens /ws/strategies.
+    def strategies(&block)
+      open_private("/ws/strategies", "strategies", {}, &block)
+    end
+
+    # Live private account feed for one connected exchange key (balance,
+    # positions, your orders/fills). Pass +api_key_id+ from +account.keys()+.
+    def private(exchange:, market: nil, api_key_id: nil, key_id: nil, symbol: nil, &block)
+      params = compact(
+        exchange: exchange, market: market,
+        apiKeyId: api_key_id, keyId: key_id, symbol: symbol
+      )
+      open_private("/ws/private", "private", params, &block)
+    end
+
+    private
+
+    def compact(hash)
+      hash.reject { |_, v| v.nil? }
+    end
+
+    def build_url(path, params)
+      q = params.merge("apiKey" => @api_key)
+      "#{@ws_url}#{path}?#{URI.encode_www_form(q)}"
+    end
+
+    def open_public(path, params, &block)
+      url = build_url(path, params.transform_keys(&:to_s))
+      MelayaWebSocket.connect(url, verify_ssl: @verify_ssl) do |ws|
+        ws.each_frame(&block)
+      end
+    end
+
+    def open_private(path, stream, params, &block)
+      body = { "stream" => stream }.merge(params.transform_keys(&:to_s))
+      ticket = @http.post("/api/v1/private/private-ticket", body)["wsTicket"]
+      url = "#{@ws_url}#{path}?#{URI.encode_www_form('wsTicket' => ticket)}"
+      MelayaWebSocket.connect(url, verify_ssl: @verify_ssl) do |ws|
+        ws.each_frame(&block)
+      end
+    end
+  end
+end

data/lib/melaya/trade.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Melaya
+  # Live trading API — credentialed order placement, account state, and
+  # position management on a CONNECTED exchange.
+  #
+  # Every method POSTs to +https://api.melaya.org/api/v1/private/<op>+; the server
+  # resolves your connected exchange credential (referenced by +api_key_id+ — see
+  # AccountAPI#keys) and forwards the call to the venue through Melaya's in-house
+  # Rust engine. Responses share an envelope:
+  # +{ ok, exchange, operation, orderId, clientOrderId, payload, data, ... }+.
+  #
+  # WARNING: these hit the REAL venue with REAL funds. The write methods
+  # (create_order, cancel_order, amend_order, cancel_all_orders, cancel_plan_orders,
+  # close_position, set_leverage, set_margin_mode, set_position_mode) move money or
+  # change account state. For risk-free testing use the sim (paper) broker or a
+  # paper strategy instead.
+  class TradeAPI
+    def initialize(http)
+      @http = http
+    end
+
+    # ── Account state (reads) ──────────────────────────────────────────────────
+
+    # Live account balance on a connected venue.
+    def balance(exchange:, api_key_id: nil, key_id: nil, market_type: nil, params: nil)
+      op("balance", exchange: exchange, apiKeyId: api_key_id, keyId: key_id,
+         marketType: market_type, params: params)
+    end
+
+    # Live open positions.
+    def positions(exchange:, api_key_id: nil, market_type: nil, symbol: nil, params: nil)
+      op("positions", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol, params: params)
+    end
+
+    # Historical positions (venue-dependent).
+    def positions_history(exchange:, api_key_id: nil, market_type: nil, symbol: nil)
+      op("positions-history", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol)
+    end
+
+    # Resting (open) orders.
+    def open_orders(exchange:, api_key_id: nil, market_type: nil, symbol: nil)
+      op("open-orders", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol)
+    end
+
+    # All orders (open + recent).
+    def orders(exchange:, api_key_id: nil, market_type: nil, symbol: nil)
+      op("orders", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol)
+    end
+
+    # Closed/filled orders.
+    def closed_orders(exchange:, api_key_id: nil, market_type: nil, symbol: nil)
+      op("closed-orders", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol)
+    end
+
+    # Your trade (fill) history.
+    def my_trades(exchange:, api_key_id: nil, market_type: nil, symbol: nil)
+      op("my-trades", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol)
+    end
+
+    # Extended trade history (venue-dependent).
+    def my_trades_history(exchange:, api_key_id: nil, market_type: nil, symbol: nil)
+      op("my-trades-history", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol)
+    end
+
+    # Resting conditional/plan (trigger) orders.
+    def plan_orders(exchange:, api_key_id: nil, market_type: nil, symbol: nil)
+      op("plan-orders", exchange: exchange, apiKeyId: api_key_id,
+         marketType: market_type, symbol: symbol)
+    end
+
+    # Current leverage for a symbol.
+    def leverage(exchange:, api_key_id: nil, symbol: nil, market_type: nil)
+      op("leverage", exchange: exchange, apiKeyId: api_key_id,
+         symbol: symbol, marketType: market_type)
+    end
+
+    # Leverage tiers / brackets for a symbol.
+    def leverage_tiers(exchange:, api_key_id: nil, symbol: nil, market_type: nil)
+      op("leverage-tiers", exchange: exchange, apiKeyId: api_key_id,
+         symbol: symbol, marketType: market_type)
+    end
+
+    # ── Order placement & management (LIVE writes — real funds) ───────────────
+
+    # Place a live order on the venue. WARNING: real money.
+    # stop_price, take_profit_price, and reduce_only are folded into +params+.
+    def create_order(exchange:, symbol:, side:, amount:,
+                     api_key_id: nil, type: "market", price: nil,
+                     market_type: nil, stop_price: nil, take_profit_price: nil,
+                     reduce_only: nil, leverage: nil, client_order_id: nil, params: nil)
+      p = (params || {}).dup
+      p["stopPrice"]       = stop_price       unless stop_price.nil?
+      p["takeProfitPrice"] = take_profit_price unless take_profit_price.nil?
+      p["reduceOnly"]      = reduce_only       unless reduce_only.nil?
+      op("create-order",
+         exchange: exchange, apiKeyId: api_key_id, symbol: symbol,
+         side: side, amount: amount, type: type, price: price,
+         marketType: market_type, leverage: leverage,
+         clientOrderId: client_order_id, params: p.empty? ? nil : p)
+    end
+
+    # Cancel a live order by id. WARNING.
+    def cancel_order(exchange:, api_key_id: nil, order_id: nil, client_order_id: nil,
+                     symbol: nil, market_type: nil)
+      op("cancel-order", exchange: exchange, apiKeyId: api_key_id,
+         orderId: order_id, clientOrderId: client_order_id,
+         symbol: symbol, marketType: market_type)
+    end
+
+    # Amend (modify) a live order. WARNING.
+    def amend_order(exchange:, api_key_id: nil, order_id: nil, symbol: nil,
+                    amount: nil, price: nil)
+      op("amend-order", exchange: exchange, apiKeyId: api_key_id,
+         orderId: order_id, symbol: symbol, amount: amount, price: price)
+    end
+
+    # Cancel every open order (optionally scoped to a symbol). WARNING.
+    def cancel_all_orders(exchange:, api_key_id: nil, symbol: nil, market_type: nil)
+      op("cancel-all-orders", exchange: exchange, apiKeyId: api_key_id,
+         symbol: symbol, marketType: market_type)
+    end
+
+    # Cancel resting plan/trigger orders. WARNING.
+    def cancel_plan_orders(exchange:, api_key_id: nil, symbol: nil, market_type: nil)
+      op("cancel-plan-orders", exchange: exchange, apiKeyId: api_key_id,
+         symbol: symbol, marketType: market_type)
+    end
+
+    # Close an open position (market reduce-only). WARNING.
+    def close_position(exchange:, symbol:, api_key_id: nil, market_type: nil)
+      op("close-position", exchange: exchange, apiKeyId: api_key_id,
+         symbol: symbol, marketType: market_type)
+    end
+
+    # Set leverage for a symbol. WARNING.
+    def set_leverage(exchange:, symbol:, leverage:, api_key_id: nil, market_type: nil)
+      op("set-leverage", exchange: exchange, apiKeyId: api_key_id,
+         symbol: symbol, leverage: leverage, marketType: market_type)
+    end
+
+    # Set margin mode (cross/isolated). WARNING.
+    def set_margin_mode(exchange:, margin_mode:, api_key_id: nil, symbol: nil, market_type: nil)
+      op("set-margin-mode", exchange: exchange, apiKeyId: api_key_id,
+         marginMode: margin_mode, symbol: symbol, marketType: market_type)
+    end
+
+    # Set position mode (one-way / hedge). WARNING.
+    def set_position_mode(exchange:, api_key_id: nil, hedged: nil, mode: nil, market_type: nil)
+      op("set-position-mode", exchange: exchange, apiKeyId: api_key_id,
+         hedged: hedged, mode: mode, marketType: market_type)
+    end
+
+    private
+
+    def op(path_op, **kwargs)
+      body = kwargs.reject { |_, v| v.nil? }
+      @http.post("/api/v1/private/#{path_op}", body)
+    end
+  end
+end

data/lib/melaya/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Melaya
+  VERSION = "0.1.0"
+end