hyperliquid 0.2.0 → 0.4.0

data/example.rb

@@ -5,54 +5,157 @@ require_relative 'lib/hyperliquid'
 
 # Example usage of the Hyperliquid Ruby SDK
 
+puts 'Hyperliquid Ruby SDK v0.4.0 - API Examples'
+puts '=' * 50
+
+# =============================================================================
+# INFO API (Read-only, no authentication required)
+# =============================================================================
+
 # Create a new SDK instance (defaults to mainnet)
 sdk = Hyperliquid.new
 
-puts 'Hyperliquid Ruby SDK v0.1 - Info API Examples'
-puts '=' * 50
+puts "\n--- INFO API EXAMPLES ---\n"
 
 # Example 1: Get all market mid prices
 begin
-  puts "\n1. Getting all market mid prices..."
+  puts '1. Getting all market mid prices...'
   mids = sdk.info.all_mids
-  puts "Found #{mids.length} markets" if mids.is_a?(Hash)
+  puts "   Found #{mids.length} markets" if mids.is_a?(Hash)
+  puts "   BTC mid: #{mids['BTC']}" if mids['BTC']
 rescue Hyperliquid::Error => e
-  puts "Error getting market mids: #{e.message}"
+  puts "   Error: #{e.message}"
 end
 
-# Example 2: Get metadata for all assets
+# Example 2: Get metadata for all perpetual assets
 begin
-  puts "\n2. Getting asset metadata..."
+  puts "\n2. Getting perpetual asset metadata..."
   meta = sdk.info.meta
-  puts 'Got metadata for universe' if meta.is_a?(Hash)
+  universe = meta['universe'] || []
+  puts "   Found #{universe.length} perpetual assets"
+  puts "   First asset: #{universe.first['name']}" if universe.any?
+rescue Hyperliquid::Error => e
+  puts "   Error: #{e.message}"
+end
+
+# Example 3: Get L2 order book
+begin
+  puts "\n3. Getting L2 order book for BTC..."
+  book = sdk.info.l2_book('BTC')
+  levels = book['levels'] || []
+  puts "   Bid levels: #{levels[0]&.length || 0}, Ask levels: #{levels[1]&.length || 0}"
 rescue Hyperliquid::Error => e
-  puts "Error getting metadata: #{e.message}"
+  puts "   Error: #{e.message}"
 end
 
-# Example 3: Use testnet
-puts "\n3. Using testnet..."
+# Example 4: Get spot metadata
+begin
+  puts "\n4. Getting spot asset metadata..."
+  spot_meta = sdk.info.spot_meta
+  tokens = spot_meta['tokens'] || []
+  puts "   Found #{tokens.length} spot tokens"
+rescue Hyperliquid::Error => e
+  puts "   Error: #{e.message}"
+end
+
+# Example 5: Use testnet
+puts "\n5. Creating testnet SDK..."
 testnet_sdk = Hyperliquid.new(testnet: true)
-puts "Testnet SDK created, base URL: #{testnet_sdk.base_url}"
+puts "   Testnet base URL: #{testnet_sdk.base_url}"
 
-# Example 4: User-specific endpoints (requires valid wallet address)
-wallet_address = "0x#{'0' * 40}" # Example placeholder address
+# Example 6: User-specific endpoints (requires valid wallet address)
+wallet_address = "0x#{'0' * 40}" # Placeholder address
 
 begin
-  puts "\n4. Getting open orders for wallet #{wallet_address[0..10]}..."
-  orders = sdk.info.open_orders(wallet_address)
-  puts "Open orders: #{orders}"
+  puts "\n6. Getting user state for #{wallet_address[0..13]}..."
+  state = sdk.info.user_state(wallet_address)
+  puts "   Account value: #{state.dig('marginSummary', 'accountValue') || 'N/A'}"
 rescue Hyperliquid::Error => e
-  puts "Error getting open orders: #{e.message}"
+  puts "   Error: #{e.message}"
 end
 
+# =============================================================================
+# EXCHANGE API (Authenticated, requires private key)
+# =============================================================================
+
+puts "\n--- EXCHANGE API EXAMPLES ---\n"
+puts "(These examples are commented out to prevent accidental execution)\n"
+
+# To use the Exchange API, create an SDK with your private key:
+#
+#   sdk = Hyperliquid.new(
+#     testnet: true,  # Use testnet for testing!
+#     private_key: ENV['HYPERLIQUID_PRIVATE_KEY']
+#   )
+#
+# Your wallet address:
+#   puts sdk.exchange.address
+#
+# Place a limit order:
+#   result = sdk.exchange.order(
+#     coin: 'BTC',
+#     is_buy: true,
+#     size: 0.001,
+#     limit_px: 50000.0,
+#     order_type: { limit: { tif: 'Gtc' } },
+#     reduce_only: false
+#   )
+#
+# Place a market order (uses slippage):
+#   result = sdk.exchange.market_order(
+#     coin: 'BTC',
+#     is_buy: true,
+#     size: 0.001,
+#     slippage: 0.01  # 1% slippage
+#   )
+#
+# Place a stop loss order:
+#   result = sdk.exchange.order(
+#     coin: 'BTC',
+#     is_buy: false,
+#     size: 0.001,
+#     limit_px: 48000.0,
+#     order_type: {
+#       trigger: {
+#         trigger_px: 49000.0,
+#         is_market: false,
+#         tpsl: 'sl'
+#       }
+#     },
+#     reduce_only: true
+#   )
+#
+# Cancel an order by OID:
+#   result = sdk.exchange.cancel(coin: 'BTC', oid: 123456789)
+#
+# Cancel an order by client order ID:
+#   result = sdk.exchange.cancel_by_cloid(coin: 'BTC', cloid: '0x...')
+#
+# Bulk cancel multiple orders:
+#   result = sdk.exchange.bulk_cancel([
+#     { coin: 'BTC', oid: 123 },
+#     { coin: 'ETH', oid: 456 }
+#   ])
+#
+# Use client order IDs for tracking:
+#   cloid = Hyperliquid::Cloid.random
+#   result = sdk.exchange.order(
+#     coin: 'BTC',
+#     is_buy: true,
+#     size: 0.001,
+#     limit_px: 50000.0,
+#     cloid: cloid
+#   )
+#   puts "Order placed with cloid: #{cloid}"
+#
+# Trade on behalf of a vault:
+#   result = sdk.exchange.order(
+#     coin: 'BTC',
+#     is_buy: true,
+#     size: 0.001,
+#     limit_px: 50000.0,
+#     vault_address: '0x...'
+#   )
+
+puts 'See commented code above for Exchange API usage patterns.'
 puts "\nSDK examples completed!"
-puts "\nAvailable Info methods:"
-puts '- all_mids() - Get all market mid prices'
-puts "- open_orders(user) - Get user's open orders"
-puts "- user_fills(user) - Get user's fill history"
-puts '- order_status(user, oid) - Get order status'
-puts "- user_state(user) - Get user's trading state"
-puts '- meta() - Get asset metadata'
-puts '- meta_and_asset_ctxs() - Get extended asset metadata'
-puts '- l2_book(coin) - Get L2 order book'
-puts '- candles_snapshot(coin, interval, start_time, end_time) - Get candlestick data'

data/lib/hyperliquid/cloid.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Hyperliquid
+  # Client Order ID for tracking orders
+  # Must be a 16-byte hex string in format: 0x + 32 hex characters
+  class Cloid
+    # Initialize a new Cloid from a raw hex string
+    # @param raw_cloid [String] Hex string in format 0x + 32 hex characters
+    # @raise [ArgumentError] If format is invalid
+    def initialize(raw_cloid)
+      @raw_cloid = raw_cloid.downcase
+      validate!
+    end
+
+    # Get the raw hex string representation
+    # @return [String] The raw cloid string
+    def to_raw
+      @raw_cloid
+    end
+
+    # String representation
+    # @return [String] The raw cloid string
+    def to_s
+      @raw_cloid
+    end
+
+    # Inspect representation
+    # @return [String] The raw cloid string
+    def inspect
+      @raw_cloid
+    end
+
+    # Equality check
+    # @param other [Cloid, String] Another Cloid or string to compare
+    # @return [Boolean] True if equal
+    def ==(other)
+      case other
+      when Cloid
+        @raw_cloid == other.to_raw
+      when String
+        @raw_cloid == other.downcase
+      else
+        false
+      end
+    end
+
+    alias eql? ==
+
+    # Hash for use in Hash keys
+    # @return [Integer] Hash value
+    def hash
+      @raw_cloid.hash
+    end
+
+    class << self
+      # Create a Cloid from an integer
+      # @param value [Integer] Integer value (0 to 2^128-1)
+      # @return [Cloid] New Cloid instance
+      # @raise [ArgumentError] If value is out of range
+      def from_int(value)
+        raise ArgumentError, 'cloid integer must be non-negative' if value.negative?
+        raise ArgumentError, 'cloid integer must be less than 2^128' if value >= 2**128
+
+        new(format('0x%032x', value))
+      end
+
+      # Create a Cloid from a hex string
+      # @param value [String] Hex string in format 0x + 32 hex characters
+      # @return [Cloid] New Cloid instance
+      def from_str(value)
+        new(value)
+      end
+
+      # Generate a random Cloid
+      # @return [Cloid] New random Cloid instance
+      def random
+        from_int(SecureRandom.random_number(2**128))
+      end
+
+      # Create a Cloid from a UUID string
+      # @param uuid [String] UUID string (with or without dashes)
+      # @return [Cloid] New Cloid instance
+      def from_uuid(uuid)
+        hex = uuid.delete('-').downcase
+        raise ArgumentError, 'UUID must be 32 hex characters' unless hex.match?(/\A[0-9a-f]{32}\z/)
+
+        new("0x#{hex}")
+      end
+    end
+
+    private
+
+    def validate!
+      return if @raw_cloid.match?(/\A0x[0-9a-f]{32}\z/)
+
+      raise ArgumentError,
+            "cloid must be '0x' followed by 32 hex characters (16 bytes). Got: #{@raw_cloid.inspect}"
+    end
+  end
+end

data/lib/hyperliquid/constants.rb

@@ -9,6 +9,7 @@ module Hyperliquid
 
     # API endpoints
     INFO_ENDPOINT = '/info'
+    EXCHANGE_ENDPOINT = '/exchange'
 
     # Request timeouts (seconds)
     DEFAULT_TIMEOUT = 30

data/lib/hyperliquid/exchange.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Hyperliquid
+  # Exchange API client for write operations (orders, cancels, etc.)
+  # Requires a private key for signing transactions
+  class Exchange
+    # Default slippage for market orders (5%)
+    DEFAULT_SLIPPAGE = 0.05
+
+    # Spot assets have indices >= 10000
+    SPOT_ASSET_THRESHOLD = 10_000
+
+    # Initialize the exchange client
+    # @param client [Hyperliquid::Client] HTTP client
+    # @param signer [Hyperliquid::Signing::Signer] EIP-712 signer
+    # @param info [Hyperliquid::Info] Info API client for metadata
+    # @param expires_after [Integer, nil] Optional global expiration timestamp
+    def initialize(client:, signer:, info:, expires_after: nil)
+      @client = client
+      @signer = signer
+      @info = info
+      @expires_after = expires_after
+      @asset_cache = nil
+    end
+
+    # Get the wallet address
+    # @return [String] Checksummed Ethereum address
+    def address
+      @signer.address
+    end
+
+    # Place a single order
+    # @param coin [String] Asset symbol (e.g., "BTC")
+    # @param is_buy [Boolean] True for buy, false for sell
+    # @param size [String, Numeric] Order size
+    # @param limit_px [String, Numeric] Limit price
+    # @param order_type [Hash] Order type config (default: { limit: { tif: "Gtc" } })
+    # @param reduce_only [Boolean] Reduce-only flag (default: false)
+    # @param cloid [Cloid, String, nil] Client order ID (optional)
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Order response
+    def order(coin:, is_buy:, size:, limit_px:, order_type: { limit: { tif: 'Gtc' } },
+              reduce_only: false, cloid: nil, vault_address: nil)
+      nonce = timestamp_ms
+
+      order_wire = build_order_wire(
+        coin: coin,
+        is_buy: is_buy,
+        size: size,
+        limit_px: limit_px,
+        order_type: order_type,
+        reduce_only: reduce_only,
+        cloid: cloid
+      )
+
+      action = {
+        type: 'order',
+        orders: [order_wire],
+        grouping: 'na'
+      }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Place multiple orders in a batch
+    # @param orders [Array<Hash>] Array of order hashes with keys:
+    #   :coin, :is_buy, :size, :limit_px, :order_type, :reduce_only, :cloid
+    # @param grouping [String] Order grouping ("na", "normalTpsl", "positionTpsl")
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Bulk order response
+    def bulk_orders(orders:, grouping: 'na', vault_address: nil)
+      nonce = timestamp_ms
+
+      order_wires = orders.map do |o|
+        build_order_wire(
+          coin: o[:coin],
+          is_buy: o[:is_buy],
+          size: o[:size],
+          limit_px: o[:limit_px],
+          order_type: o[:order_type] || { limit: { tif: 'Gtc' } },
+          reduce_only: o[:reduce_only] || false,
+          cloid: o[:cloid]
+        )
+      end
+
+      action = {
+        type: 'order',
+        orders: order_wires,
+        grouping: grouping
+      }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Place a market order (aggressive limit IoC with slippage)
+    # @param coin [String] Asset symbol
+    # @param is_buy [Boolean] True for buy, false for sell
+    # @param size [String, Numeric] Order size
+    # @param slippage [Float] Slippage tolerance (default: 0.05 = 5%)
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Order response
+    def market_order(coin:, is_buy:, size:, slippage: DEFAULT_SLIPPAGE, vault_address: nil)
+      # Get current mid price
+      mids = @info.all_mids
+      mid = mids[coin]&.to_f
+      raise ArgumentError, "Unknown asset or no price available: #{coin}" unless mid&.positive?
+
+      # Apply slippage and round to appropriate precision
+      slippage_price = calculate_slippage_price(coin, mid, is_buy, slippage)
+
+      order(
+        coin: coin,
+        is_buy: is_buy,
+        size: size,
+        limit_px: slippage_price,
+        order_type: { limit: { tif: 'Ioc' } },
+        vault_address: vault_address
+      )
+    end
+
+    # Cancel a single order by order ID
+    # @param coin [String] Asset symbol
+    # @param oid [Integer] Order ID
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Cancel response
+    def cancel(coin:, oid:, vault_address: nil)
+      nonce = timestamp_ms
+
+      action = {
+        type: 'cancel',
+        cancels: [{ a: asset_index(coin), o: oid }]
+      }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Cancel a single order by client order ID
+    # @param coin [String] Asset symbol
+    # @param cloid [Cloid, String] Client order ID
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Cancel response
+    def cancel_by_cloid(coin:, cloid:, vault_address: nil)
+      nonce = timestamp_ms
+      cloid_raw = normalize_cloid(cloid)
+
+      action = {
+        type: 'cancelByCloid',
+        cancels: [{ asset: asset_index(coin), cloid: cloid_raw }]
+      }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Cancel multiple orders by order ID
+    # @param cancels [Array<Hash>] Array of cancel hashes with :coin and :oid
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Bulk cancel response
+    def bulk_cancel(cancels:, vault_address: nil)
+      nonce = timestamp_ms
+
+      cancel_wires = cancels.map do |c|
+        { a: asset_index(c[:coin]), o: c[:oid] }
+      end
+      action = { type: 'cancel', cancels: cancel_wires }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Cancel multiple orders by client order ID
+    # @param cancels [Array<Hash>] Array of cancel hashes with :coin and :cloid
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Bulk cancel by cloid response
+    def bulk_cancel_by_cloid(cancels:, vault_address: nil)
+      nonce = timestamp_ms
+
+      cancel_wires = cancels.map do |c|
+        { asset: asset_index(c[:coin]), cloid: normalize_cloid(c[:cloid]) }
+      end
+      action = { type: 'cancelByCloid', cancels: cancel_wires }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Clear the asset metadata cache
+    # Call this if metadata has been updated
+    def reload_metadata!
+      @asset_cache = nil
+    end
+
+    private
+
+    # Build order wire format
+    def build_order_wire(coin:, is_buy:, size:, limit_px:, order_type:, reduce_only:, cloid:)
+      wire = {
+        a: asset_index(coin),
+        b: is_buy,
+        p: float_to_wire(limit_px),
+        s: float_to_wire(size),
+        r: reduce_only,
+        t: order_type_to_wire(order_type)
+      }
+      wire[:c] = normalize_cloid(cloid) if cloid
+      wire
+    end
+
+    # Get current timestamp in milliseconds
+    def timestamp_ms
+      (Time.now.to_f * 1000).to_i
+    end
+
+    # Get asset index for a coin symbol
+    # @param coin [String] Asset symbol
+    # @return [Integer] Asset index
+    def asset_index(coin)
+      load_asset_cache unless @asset_cache
+      @asset_cache[:indices][coin] || raise(ArgumentError, "Unknown asset: #{coin}")
+    end
+
+    # Get asset metadata for a coin symbol
+    # @param coin [String] Asset symbol
+    # @return [Hash] Asset metadata with :sz_decimals and :is_spot
+    def asset_metadata(coin)
+      load_asset_cache unless @asset_cache
+      @asset_cache[:metadata][coin] || raise(ArgumentError, "Unknown asset: #{coin}")
+    end
+
+    # Load asset metadata from Info API (perps and spot)
+    def load_asset_cache
+      @asset_cache = { indices: {}, metadata: {} }
+
+      # Load perpetual assets
+      meta = @info.meta
+      meta['universe'].each_with_index do |asset, index|
+        name = asset['name']
+        @asset_cache[:indices][name] = index
+        @asset_cache[:metadata][name] = {
+          sz_decimals: asset['szDecimals'],
+          is_spot: false
+        }
+      end
+
+      # Load spot assets (index starts at SPOT_ASSET_THRESHOLD)
+      spot_meta = @info.spot_meta
+      spot_meta['universe'].each_with_index do |pair, index|
+        name = pair['name']
+        spot_index = index + SPOT_ASSET_THRESHOLD
+        @asset_cache[:indices][name] = spot_index
+        @asset_cache[:metadata][name] = {
+          sz_decimals: pair['szDecimals'] || 0,
+          is_spot: true
+        }
+      end
+    end
+
+    # Convert float to wire format (string representation)
+    # Maintains parity with official Python SDK
+    # - 8 decimal precision
+    # - Rounding tolerance validation (1e-12)
+    # - Decimal normalization (remove trailing zeros)
+    # @param value [String, Numeric] Value to convert
+    # @return [String] Wire format string
+    def float_to_wire(value)
+      decimal = BigDecimal(value.to_s)
+
+      # Format to 8 decimal places
+      rounded_str = format('%.8f', decimal)
+      rounded = BigDecimal(rounded_str)
+
+      # Validate rounding tolerance
+      raise ArgumentError, "float_to_wire causes rounding: #{value}" if (rounded - decimal).abs >= BigDecimal('1e-12')
+
+      # Negative zero edge case
+      rounded_str = '0.00000000' if rounded_str == '-0.00000000'
+
+      # Normalize: remove trailing zeros and unnecessary decimal point
+      # BigDecimal#to_s('F') gives fixed-point notation
+      normalized = BigDecimal(rounded_str).to_s('F')
+      # Remove trailing zeros after decimal point, and trailing decimal point
+      normalized.sub(/(\.\d*?)0+\z/, '\1').sub(/\.\z/, '')
+    end
+
+    # Calculate slippage price for market orders
+    # Maintains parity with official Python SDK
+    # 1. Apply slippage to mid price
+    # 2. Round to 5 significant figures
+    # 3. Round to asset-specific decimal places
+    # @param coin [String] Asset symbol
+    # @param mid [Float] Current mid price
+    # @param is_buy [Boolean] True for buy
+    # @param slippage [Float] Slippage tolerance
+    # @return [String] Formatted price string
+    def calculate_slippage_price(coin, mid, is_buy, slippage)
+      # Apply slippage
+      px = is_buy ? mid * (1 + slippage) : mid * (1 - slippage)
+
+      # Get asset metadata
+      metadata = asset_metadata(coin)
+      sz_decimals = metadata[:sz_decimals]
+      is_spot = metadata[:is_spot]
+
+      # Round to 5 significant figures first
+      sig_figs_str = format('%.5g', px)
+      sig_figs_price = sig_figs_str.to_f
+
+      # Calculate decimal places: (6 for perp, 8 for spot) - szDecimals
+      base_decimals = is_spot ? 8 : 6
+      decimal_places = [base_decimals - sz_decimals, 0].max
+
+      # Round to decimal places
+      rounded = sig_figs_price.round(decimal_places)
+
+      # Format with fixed decimal places
+      format("%.#{decimal_places}f", rounded)
+    end
+
+    # Convert cloid to raw string format
+    # @param cloid [Cloid, String, nil] Client order ID
+    # @return [String, nil] Raw cloid string
+    def normalize_cloid(cloid)
+      case cloid
+      when nil
+        nil
+      when Cloid
+        cloid.to_raw
+      when String
+        # Validate format
+        unless cloid.match?(/\A0x[0-9a-fA-F]{32}\z/i)
+          raise ArgumentError,
+                "cloid must be '0x' followed by 32 hex characters (16 bytes). Got: #{cloid.inspect}"
+        end
+        cloid.downcase
+      else
+        raise ArgumentError, "cloid must be Cloid, String, or nil. Got: #{cloid.class}"
+      end
+    end
+
+    # Convert order type to wire format
+    # @param order_type [Hash] Order type configuration
+    # @return [Hash] Wire format order type
+    def order_type_to_wire(order_type)
+      if order_type[:limit]
+        { limit: { tif: order_type[:limit][:tif] || 'Gtc' } }
+      elsif order_type[:trigger]
+        trigger = order_type[:trigger]
+
+        # Validate required fields
+        raise ArgumentError, 'Trigger orders require :trigger_px' unless trigger[:trigger_px]
+        raise ArgumentError, 'Trigger orders require :tpsl' unless trigger[:tpsl]
+        unless %w[tp sl].include?(trigger[:tpsl])
+          raise ArgumentError, "tpsl must be 'tp' or 'sl', got: #{trigger[:tpsl]}"
+        end
+
+        {
+          trigger: {
+            isMarket: trigger[:is_market] || false,
+            triggerPx: float_to_wire(trigger[:trigger_px]),
+            tpsl: trigger[:tpsl]
+          }
+        }
+      else
+        raise ArgumentError, 'order_type must specify :limit or :trigger'
+      end
+    end
+
+    # Post an action to the exchange endpoint
+    def post_action(action, signature, nonce, vault_address)
+      payload = {
+        action: action,
+        nonce: nonce,
+        signature: signature
+      }
+      payload[:vaultAddress] = vault_address if vault_address
+      payload[:expiresAfter] = @expires_after if @expires_after
+
+      @client.post(Constants::EXCHANGE_ENDPOINT, payload)
+    end
+  end
+end