melaya 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b379d2fb9b62ca5b6420c3fd1b62eddb2fdd1a4912b6ee13b467199352ffb1a8
+  data.tar.gz: 77644a810237149040ff1f7557885ac049017b00ae0aef6c5221050b78c744de
+SHA512:
+  metadata.gz: 9a802bbcc841b6a2a5ff36ee0364f81d0f2a0d645611da784fa267b70a9092bbc1277ebd7f834646eb99200b5e73357ed928d2473efdf27cae70295a0b95f245
+  data.tar.gz: a0b627edbfa5dd8e770ebd1c36fd9c3fd9a8ee953cc8cb38dc66847451c616b7589691b70a93332eab0a425d93f96905547d3a5286439e955c16650c89d259fa

data/README.md

@@ -0,0 +1,163 @@
+# melaya
+
+Official Ruby SDK for the **[Melaya](https://melaya.org)** trading platform — normalized market data, paper + live trading, backtesting, and an AI agentic trading crew across **70+ venues**, powered by an in-house Rust engine.
+
+- Zero runtime gem dependencies (stdlib `net/http`, `openssl`, `json` only).
+- Pure Ruby WebSocket client (RFC 6455) — no external gem required for streaming.
+- Full market data, strategies, sim trading, backtesting, and streaming from one client.
+
+## Install
+
+Add to your `Gemfile`:
+
+```ruby
+gem "melaya", path: "path/to/sdk-ruby"   # local checkout
+```
+
+Or once published to RubyGems:
+
+```bash
+gem install melaya
+```
+
+## Quick start
+
+```ruby
+require "melaya"
+
+melaya = Melaya::Client.new(api_key: ENV["MELAYA_API_KEY"])  # keys are prefixed mk_
+
+# REST — normalized ticker from any of 70+ venues
+t = melaya.market.ticker(exchange: "binance", symbol: "BTC/USDT", market: "spot")
+puts t["last"], t["bid"], t["ask"]
+
+# Order book
+ob = melaya.market.orderbook(exchange: "bybit", symbol: "BTC/USDT", market: "spot", limit: 20)
+
+# Candles
+candles = melaya.market.ohlcv(exchange: "okx", symbol: "ETH/USDT", timeframe: "1h", limit: 200)
+```
+
+## Streaming
+
+```ruby
+# Live ticker (block form — closes when block returns)
+melaya.stream.ticker(exchange: "binance", symbol: "BTC/USDT", market: "spot") do |frame|
+  puts frame["last"]
+  break  # close after first frame
+end
+
+# Liquidation firehose
+melaya.stream.liquidations(exchange: "binance") do |ev|
+  puts ev["side"], ev["notional"]
+  break
+end
+```
+
+## Trading
+
+```ruby
+# Account: connected exchange keys and usage
+keys  = melaya.account.keys    # [{ "apiKeyId" => "BINANCEUSDM_0", "exchange" => "binanceusdm", ... }]
+usage = melaya.account.usage
+
+# Strategies — launch immediately. Paper (dry_run: true) needs no exchange key.
+# SDK-launchable strategies are `custom` Rhai definitions.
+result = melaya.strategies.create(
+  name:          "my-bot",
+  strategy_type: "custom",
+  exchange:      "binanceusdm",
+  symbol:        "BTC/USDT:USDT",
+  market:        "FUTURES",
+  dry_run:       true,
+  params: {
+    "language"   => "rhai",
+    "definition" => 'fn evaluate() { emit_long(param("qty")); }',
+    "qty"        => 0.001,
+  }
+)
+sid = result["strategyId"]
+melaya.strategies.pause(sid)
+melaya.strategies.resume(sid)
+trades = melaya.strategies.trades(sid)
+
+# Paper trading (sim broker) — synthetic fills, no venue state
+bal  = melaya.sim.balance(strategy_id: sid)
+fill = melaya.sim.create_order(
+  strategy_id: sid,
+  exchange: "binanceusdm",
+  symbol: "BTC/USDT:USDT",
+  side: "buy",
+  type: "market",
+  amount: 0.001,
+  market: "FUTURES"
+)
+
+# Backtest on the Rust engine
+r = melaya.backtest.start(
+  "strategyType" => "custom",
+  "exchange"     => "binance",
+  "symbol"       => "BTC/USDT",
+  "timeframe"    => "1h",
+  "since_ms"     => (Time.now.to_i - 90 * 86400) * 1000,
+  "until_ms"     => Time.now.to_i * 1000,
+  "language"     => "rhai",
+  "definition"   => 'fn evaluate() { emit_long(param("qty")); }',
+  "params"       => { "qty" => 0.001 }
+)
+job_id = r["job_id"]
+loop do
+  j = melaya.backtest.job(job_id)
+  break if %w[done error].include?(j["status"])
+  sleep 2
+end
+result = melaya.backtest.results(job_id)
+
+# Private streaming (ticket minted automatically)
+melaya.stream.strategies do |ev|
+  puts ev["type"], ev["strategyId"]
+  break
+end
+
+# Always clean up
+melaya.strategies.stop(sid)
+melaya.strategies.delete(sid)
+```
+
+## Authentication
+
+Create an API key in the dashboard (**melaya.org → Settings → API Keys**). Keys are prefixed `mk_`; the SDK sends it automatically on every REST call and WebSocket connection.
+
+Public market-data and account/strategy reads work with the `mk_` key alone. **Live** order placement and live strategy launches additionally require a connected exchange key — connect one in **Settings → Connectors**, then reference it by `apiKeyId`. Paper trading and backtesting never touch a venue and need no exchange credentials.
+
+## TLS verification
+
+The SDK verifies TLS certificates by default. To disable on a dev box with TLS interception:
+
+```bash
+MELAYA_INSECURE_TLS=1 ruby your_script.rb
+```
+
+Or pass `verify_ssl: false` to the constructor. **Never disable TLS in production.**
+
+## API surface
+
+| Area | Methods |
+|---|---|
+| Reference | `market.list_exchanges`, `catalog_counts` |
+| Market data | `market.ticker`, `orderbook`, `ohlcv`, `ohlcv_multi`, `trades`, `markets`, `currencies`, `market_constraints`, `status`, `time` |
+| Batch / derivatives | `market.tickers`, `funding_rates`, `funding_rate_history`, `funding_rate_history_multi`, `open_interest`, `open_interest_history`, `open_interest_history_multi`, `instruments`, `liquidation_events` |
+| Prediction markets | `market.prediction_markets` (polymarket, kalshi, drift_pm, sxbet, azuro, overtime) |
+| Account | `account.keys`, `usage`, `api_key_status` |
+| Strategies | `strategies.create`, `list`, `get`, `pause`, `resume`, `stop`, `delete`, `update_params`, `status`, `performance`, `executions`, `trades`, `logs` |
+| AI optimizer | `strategies.ai_opt_start`, `ai_opt_status`, `ai_opt_approve`, `ai_opt_stop`, `ai_opt_runs` |
+| Paper trading | `sim.balance`, `positions`, `open_orders`, `my_trades`, `create_order`, `cancel_order`, `list_accounts` |
+| Backtesting | `backtest.start`, `job`, `results`, `trades`, `sweep`, `list`, `favorites`, `funding_range`, `cancel`, `delete`, `delete_all` |
+| Public streaming | `stream.ticker`, `orderbook`, `ohlcv`, `trades`, `liquidations` |
+| Private streaming | `stream.strategies`, `stream.private` |
+
+Full docs: **[melaya.org/docs](https://melaya.org/docs)**.
+
+## License
+
+[Apache-2.0](../../LICENSE)

data/lib/melaya/account.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Melaya
+  # Account API — authenticated reads about your Melaya account.
+  #
+  # Connected-exchange key references (masked), tier limits, and live usage
+  # counters. Requires an mk_ key on the private plane.
+  class AccountAPI
+    def initialize(http)
+      @http = http
+    end
+
+    # The exchange API keys connected to your account. +api_key+ is masked
+    # (display-only); use +api_key_id+ (e.g. BINANCEUSDM_0) when launching
+    # strategies or minting a private stream ticket.
+    def keys
+      @http.get("/api/v1/private/keys")["keys"]
+    end
+
+    # Tier, plan limits, and live usage counters (mirrors the dashboard's usage page).
+    def usage
+      @http.get("/api/v1/private/usage")
+    end
+
+    # Status of your platform API key (tier, max concurrent connections).
+    def api_key_status
+      @http.get("/api/v1/private/api-key")
+    end
+  end
+end

data/lib/melaya/backtest.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Melaya
+  # Backtest API — run strategies against historical data on the Rust engine.
+  #
+  # Start a single run or a parameter sweep (grid / random), poll the job,
+  # then pull metrics, the equity curve, and the trade list. All backtests run
+  # natively on Melaya's in-house engine — no per-venue SDK in the loop.
+  #
+  # Maps to https://api.melaya.org/api/v1/private/backtest/* on the private plane.
+  class BacktestAPI
+    def initialize(http)
+      @http = http
+    end
+
+    # Start a backtest. +mode+ defaults to a single run; pass "grid_sweep" /
+    # "random_sweep" with +param_ranges+ to fan out a parameter search.
+    # Returns a hash with "job_id" (and optionally "count").
+    #
+    # @param body [Hash] see BacktestStart type in the reference SDKs
+    def start(body)
+      @http.post("/api/v1/private/backtest/start", body)
+    end
+
+    # Job status + progress (+status+, +progress_pct+, ...).
+    # @param job_id [String]
+    def job(job_id)
+      @http.get("/api/v1/private/backtest/jobs/#{job_id}")
+    end
+
+    # Metrics, equity curve, and OHLCV for a completed job.
+    # @param job_id [String]
+    def results(job_id)
+      @http.get("/api/v1/private/backtest/results/#{job_id}")["result"]
+    end
+
+    # The trade list for a completed job (default 500, max 5000 per call).
+    # @param job_id [String]
+    # @param limit [Integer, nil]
+    # @param offset [Integer, nil]
+    def trades(job_id, limit: nil, offset: nil)
+      @http.get("/api/v1/private/backtest/trades/#{job_id}",
+        "limit" => limit, "offset" => offset
+      )["trades"]
+    end
+
+    # Ranked children of a sweep parent (default objective: sharpe DESC).
+    # @param parent_id [String]
+    # @param objective [String, nil]
+    # @param limit [Integer, nil]
+    def sweep(parent_id, objective: nil, limit: nil)
+      @http.get("/api/v1/private/backtest/sweep/#{parent_id}",
+        "objective" => objective, "limit" => limit
+      )
+    end
+
+    # Your backtest jobs, newest first.
+    # @param limit [Integer, nil]
+    # @param offset [Integer, nil]
+    def list(limit: nil, offset: nil)
+      @http.get("/api/v1/private/backtest",
+        "limit" => limit, "offset" => offset
+      ).dig("data", "jobs")
+    end
+
+    # Your favorited backtest jobs (Forge tier and above).
+    # @param limit [Integer, nil]
+    # @param offset [Integer, nil]
+    def favorites(limit: nil, offset: nil)
+      @http.get("/api/v1/private/backtest/favorites",
+        "limit" => limit, "offset" => offset
+      ).dig("data", "jobs")
+    end
+
+    # Earliest funding-rate timestamp available for an exchange+symbol (ms, or nil).
+    # @param exchange [String]
+    # @param symbol [String]
+    def funding_range(exchange:, symbol:)
+      @http.get("/api/v1/private/backtest/funding-range",
+        "exchange" => exchange, "symbol" => symbol
+      )["earliest_ms"]
+    end
+
+    # Cancel an in-flight job.
+    # @param job_id [String]
+    def cancel(job_id)
+      @http.post("/api/v1/private/backtest/#{job_id}/cancel")
+    end
+
+    # Soft-delete a single job.
+    # @param job_id [String]
+    def delete(job_id)
+      @http.delete("/api/v1/private/backtest/#{job_id}")
+    end
+
+    # Soft-delete every non-favorited job. Returns a hash with "deleted" count.
+    def delete_all
+      @http.delete("/api/v1/private/backtest")
+    end
+  end
+end

data/lib/melaya/errors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Melaya
+  # Raised for non-2xx REST responses or ok:false envelopes.
+  class MelayaError < StandardError
+    attr_reader :status, :code, :body
+
+    def initialize(message, status: 0, code: nil, body: nil)
+      super(message)
+      @status = status
+      @code   = code
+      @body   = body
+    end
+  end
+end

data/lib/melaya/http_client.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "openssl"
+
+require_relative "errors"
+
+module Melaya
+  # Internal HTTP client. Injects the API key on every call as both
+  # a query-param (?apiKey=) and Authorization: Bearer header.
+  class HttpClient
+    DEFAULT_BASE_URL = "https://api.melaya.org"
+
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, verify_ssl: true)
+      @api_key    = api_key
+      @base_uri   = URI.parse(base_url.chomp("/"))
+      @verify_ssl = verify_ssl
+    end
+
+    def get(path, params = {})
+      request(:get, path, params: params)
+    end
+
+    def post(path, body = nil)
+      request(:post, path, body: body)
+    end
+
+    def delete(path, params = {})
+      request(:delete, path, params: params)
+    end
+
+    private
+
+    def build_uri(path, params = {})
+      uri = URI.parse("#{@base_uri}#{path}")
+      query = { "apiKey" => @api_key }
+      params.each { |k, v| query[k.to_s] = v.to_s unless v.nil? }
+      uri.query = URI.encode_www_form(query)
+      uri
+    end
+
+    def request(method, path, params: {}, body: nil)
+      uri = build_uri(path, params)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.verify_mode = @verify_ssl ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      http.open_timeout = 15
+      http.read_timeout = 60
+
+      req = case method
+            when :get    then Net::HTTP::Get.new(uri)
+            when :post   then Net::HTTP::Post.new(uri)
+            when :delete then Net::HTTP::Delete.new(uri)
+            else raise ArgumentError, "Unknown HTTP method: #{method}"
+            end
+
+      req["Authorization"] = "Bearer #{@api_key}"
+      req["Accept"]        = "application/json"
+
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+
+      resp = http.request(req)
+      parse(resp)
+    end
+
+    def parse(resp)
+      text = resp.body.to_s.strip
+      data = begin
+        text.empty? ? nil : JSON.parse(text)
+      rescue JSON::ParserError
+        text
+      end
+
+      if resp.code.to_i >= 400
+        code = data.is_a?(Hash) ? data["error"] : nil
+        msg  = "Melaya API #{resp.code}" + (code ? " (#{code})" : "")
+        raise MelayaError.new(msg, status: resp.code.to_i, code: code, body: data)
+      end
+
+      # The API wraps every payload in { "ok": true/false, ... }.
+      # ok:false is a request-level failure — raise instead of returning silently.
+      if data.is_a?(Hash) && data["ok"] == false
+        code = data["error"]
+        msg  = "Melaya API request failed" + (code ? ": #{code}" : "")
+        raise MelayaError.new(msg, status: resp.code.to_i, code: code, body: data)
+      end
+
+      data
+    end
+  end
+end

data/lib/melaya/market.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Melaya
+  # REST market-data API — normalized across all 70+ venues.
+  #
+  # Every method maps to a documented endpoint under
+  # https://api.melaya.org/api/v1/market/*. Unwraps the inner data key from the
+  # {ok, <data>} envelope.
+  class MarketAPI
+    def initialize(http)
+      @http = http
+    end
+
+    # List the exchanges Melaya supports right now (the source of truth).
+    def list_exchanges
+      @http.get("/api/v1/market/list-exchanges")["exchanges"]
+    end
+
+    # Best bid/ask, last price, and 24h aggregates for one symbol.
+    # @param exchange [String]
+    # @param symbol [String]
+    # @param market [String, nil] e.g. "spot", "future", "swap"
+    def ticker(exchange:, symbol:, market: nil)
+      @http.get("/api/v1/market/ticker",
+        "exchange" => exchange, "symbol" => symbol, "market" => market
+      )["ticker"]
+    end
+
+    # Order book to a given depth.
+    def orderbook(exchange:, symbol:, limit: nil, market: nil)
+      @http.get("/api/v1/market/orderbook",
+        "exchange" => exchange, "symbol" => symbol, "limit" => limit, "market" => market
+      )["orderbook"]
+    end
+
+    # OHLCV candles. Each candle is [timestamp, open, high, low, close, volume].
+    def ohlcv(exchange:, symbol:, timeframe:, limit: nil, market: nil)
+      @http.get("/api/v1/market/ohlcv",
+        "exchange" => exchange, "symbol" => symbol, "timeframe" => timeframe,
+        "limit" => limit, "market" => market
+      )["candles"]
+    end
+
+    # Recent public trades.
+    def trades(exchange:, symbol:, market: nil)
+      @http.get("/api/v1/market/trades",
+        "exchange" => exchange, "symbol" => symbol, "market" => market
+      )["trades"]
+    end
+
+    # Tradable markets on a venue.
+    def markets(exchange:)
+      @http.get("/api/v1/market/markets", "exchange" => exchange)["markets"]
+    end
+
+    # Listed currencies on a venue. (Not supported on every venue.)
+    def currencies(exchange:)
+      @http.get("/api/v1/market/currencies", "exchange" => exchange)["currencies"]
+    end
+
+    # Operational status: ok / maintenance / degraded.
+    def status(exchange:)
+      @http.get("/api/v1/market/status", "exchange" => exchange)["status"]
+    end
+
+    # Exchange server time.
+    def time(exchange:)
+      @http.get("/api/v1/market/time", "exchange" => exchange)["time"]
+    end
+
+    # ── Batch / derivatives (POST) ──────────────────────────────────────────
+
+    # Tickers for many symbols on one venue in a single call. Keyed by symbol.
+    def tickers(exchange:, symbols:, market: nil)
+      body = compact("exchange" => exchange, "symbols" => symbols, "market" => market)
+      @http.post("/api/v1/market/tickers", body)["tickers"]
+    end
+
+    # Latest funding rates for perpetuals. Keyed by symbol.
+    def funding_rates(exchange:, symbols:, market: nil)
+      body = compact("exchange" => exchange, "symbols" => symbols, "market" => market)
+      @http.post("/api/v1/market/funding-rates", body)["rates"]
+    end
+
+    # Funding-rate history.
+    def funding_rate_history(exchange:, symbol:, hours: nil, market: nil)
+      body = compact("exchange" => exchange, "symbol" => symbol, "hours" => hours, "market" => market)
+      @http.post("/api/v1/market/funding-rate-history", body)["history"]
+    end
+
+    # Open interest for one or more perpetuals. Keyed by symbol.
+    def open_interest(exchange:, symbols:, market: nil)
+      body = compact("exchange" => exchange, "symbols" => symbols, "market" => market)
+      @http.post("/api/v1/market/open-interest", body)["openInterest"]
+    end
+
+    # Open-interest history.
+    def open_interest_history(exchange:, symbol:, hours: nil, market: nil)
+      body = compact("exchange" => exchange, "symbol" => symbol, "hours" => hours, "market" => market)
+      @http.post("/api/v1/market/open-interest-history", body)["history"]
+    end
+
+    # Instrument list + trading constraints (tick size, min notional, qty step).
+    def instruments(exchange:, market: nil)
+      body = compact("exchange" => exchange, "market" => market)
+      @http.post("/api/v1/market/instruments", body)
+    end
+
+    # Cross-exchange liquidation events (historical query).
+    def liquidation_events(exchange: nil, symbol: nil, since_ms: nil, limit: nil)
+      body = compact("exchange" => exchange, "symbol" => symbol, "sinceMs" => since_ms, "limit" => limit)
+      @http.post("/api/v1/market/liquidation-events", body)["events"]
+    end
+
+    # Multi-symbol OHLCV in one call. Returns candle arrays keyed by symbol.
+    def ohlcv_multi(exchange:, symbols:, timeframe:, limit: nil, market: nil)
+      body = compact("exchange" => exchange, "symbols" => symbols, "timeframe" => timeframe,
+                     "limit" => limit, "market" => market)
+      @http.post("/api/v1/market/ohlcv-multi", body)["perSymbol"]
+    end
+
+    # Trading constraints for one symbol (tick size, min notional, qty step, leverage).
+    def market_constraints(exchange:, symbol:, market: nil)
+      body = compact("exchange" => exchange, "symbol" => symbol, "market" => market)
+      @http.post("/api/v1/market/market-constraints", body)["constraints"]
+    end
+
+    # Funding-rate history for one symbol across several venues. Keyed by exchange.
+    def funding_rate_history_multi(exchanges:, symbol:, hours: nil)
+      body = compact("exchanges" => exchanges, "symbol" => symbol, "hours" => hours)
+      @http.post("/api/v1/market/funding-rate-history-multi", body)["perExchange"]
+    end
+
+    # Open-interest history for one symbol across several venues. Keyed by exchange.
+    def open_interest_history_multi(exchanges:, symbol:, hours: nil)
+      body = compact("exchanges" => exchanges, "symbol" => symbol, "hours" => hours)
+      @http.post("/api/v1/market/open-interest-history-multi", body)["perExchange"]
+    end
+
+    # Prediction-market listings for a venue (polymarket, kalshi, drift_pm, sxbet, azuro, overtime).
+    def prediction_markets(venue: "polymarket")
+      @http.post("/api/v1/market/pm-markets", { "venue" => venue })["markets"]
+    end
+
+    # Live platform catalog counts (agentic tools, subagents, by category). Public.
+    def catalog_counts
+      @http.get("/api/v1/public/catalog-counts")
+    end
+
+    private
+
+    def compact(hash)
+      hash.reject { |_, v| v.nil? }
+    end
+  end
+end

data/lib/melaya/sim.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Melaya
+  # Paper-trading (sim broker) API.
+  #
+  # The sim broker synthesises fills from Melaya's live ticker tape and keeps a
+  # virtual wallet per strategy — no venue-side state changes, no exchange
+  # credentials needed. Every call is scoped to a +strategy_id+.
+  #
+  # Create a paper strategy first:
+  #   result = melaya.strategies.create(name: "test", strategy_type: "custom", ...)
+  #   sid = result["strategyId"]
+  class SimAPI
+    def initialize(http)
+      @http = http
+    end
+
+    # Paper accounts (one virtual wallet per paper strategy).
+    def list_accounts
+      r = @http.get("/api/v1/private/sim/list-accounts")
+      r.is_a?(Array) ? r : (r.is_a?(Hash) ? (r["accounts"] || []) : [])
+    end
+
+    # Virtual balance for a paper strategy (equity, realized/unrealized PnL, free/used).
+    # @param strategy_id [String]
+    # @param asset [String, nil]
+    def balance(strategy_id:, asset: nil)
+      @http.get("/api/v1/private/sim/balance",
+        "strategy_id" => strategy_id, "asset" => asset
+      )
+    end
+
+    # Open paper positions for a strategy.
+    def positions(strategy_id:)
+      r = @http.get("/api/v1/private/sim/positions", "strategy_id" => strategy_id)
+      r.is_a?(Array) ? r : (r.is_a?(Hash) ? (r["positions"] || []) : [])
+    end
+
+    # Resting paper orders for a strategy.
+    def open_orders(strategy_id:)
+      r = @http.get("/api/v1/private/sim/open-orders", "strategy_id" => strategy_id)
+      r.is_a?(Array) ? r : (r.is_a?(Hash) ? (r["orders"] || []) : [])
+    end
+
+    # Filled paper trades for a strategy.
+    def my_trades(strategy_id:)
+      r = @http.get("/api/v1/private/sim/my-trades", "strategy_id" => strategy_id)
+      r.is_a?(Array) ? r : (r.is_a?(Hash) ? (r["trades"] || []) : [])
+    end
+
+    # Place a paper order. Fills synthesise from the live ticker; nothing hits the venue.
+    #
+    # @param strategy_id [String]
+    # @param exchange [String]
+    # @param symbol [String]
+    # @param side [String] "buy" or "sell"
+    # @param amount [Numeric]
+    # @param type [String] "market" or "limit" (default "market")
+    # @param price [Numeric, nil] required for limit orders
+    # @param market [String, nil]
+    # @param leverage [Numeric, nil]
+    # @param reduce_only [Boolean, nil]
+    # @param sl_price [Numeric, nil]
+    # @param tp_price [Numeric, nil]
+    # @param client_order_id [String, nil]
+    # @param params [Hash, nil]
+    def create_order(strategy_id:, exchange:, symbol:, side:, amount:,
+                     type: "market", price: nil, market: nil, leverage: nil,
+                     reduce_only: nil, sl_price: nil, tp_price: nil,
+                     client_order_id: nil, params: nil)
+      body = {
+        "strategy_id"      => strategy_id,
+        "exchange"         => exchange,
+        "symbol"           => symbol,
+        "side"             => side,
+        "amount"           => amount,
+        "order_type"       => type,
+        "orderType"        => type,
+        "price"            => price,
+        "market"           => market,
+        "market_type"      => market,
+        "leverage"         => leverage,
+        "reduceOnly"       => reduce_only,
+        "slPrice"          => sl_price,
+        "tpPrice"          => tp_price,
+        "client_order_id"  => client_order_id,
+        "clientOrderId"    => client_order_id,
+        "params"           => params,
+      }.reject { |_, v| v.nil? }
+      @http.post("/api/v1/private/sim/create-order", body)
+    end
+
+    # Cancel a resting paper order.
+    #
+    # @param strategy_id [String]
+    # @param order_id [String]
+    # @param symbol [String, nil]
+    # @param exchange [String, nil]
+    def cancel_order(strategy_id:, order_id:, symbol: nil, exchange: nil)
+      body = {
+        "strategy_id" => strategy_id,
+        "order_id"    => order_id,
+        "orderId"     => order_id,
+        "symbol"      => symbol,
+        "exchange"    => exchange,
+      }.reject { |_, v| v.nil? }
+      @http.post("/api/v1/private/sim/cancel-order", body)
+    end
+  end
+end