hyperliquid 0.4.1 → 0.6.0

data/lib/hyperliquid/exchange.rb

@@ -213,6 +213,362 @@ module Hyperliquid
       post_action(action, signature, nonce, vault_address)
     end
 
+    # Modify a single existing order
+    # @param oid [Integer, Cloid, String] Order ID or client order ID to modify
+    # @param coin [String] Asset symbol (e.g., "BTC")
+    # @param is_buy [Boolean] True for buy, false for sell
+    # @param size [String, Numeric] New order size
+    # @param limit_px [String, Numeric] New 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 for the modified order (optional)
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Modify response
+    def modify_order(oid:, coin:, is_buy:, size:, limit_px:,
+                     order_type: { limit: { tif: 'Gtc' } },
+                     reduce_only: false, cloid: nil, vault_address: nil)
+      batch_modify(
+        modifies: [{
+          oid: oid, coin: coin, is_buy: is_buy, size: size,
+          limit_px: limit_px, order_type: order_type,
+          reduce_only: reduce_only, cloid: cloid
+        }],
+        vault_address: vault_address
+      )
+    end
+
+    # Modify multiple orders at once
+    # @param modifies [Array<Hash>] Array of modify hashes with keys:
+    #   :oid, :coin, :is_buy, :size, :limit_px, :order_type, :reduce_only, :cloid
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Batch modify response
+    def batch_modify(modifies:, vault_address: nil)
+      nonce = timestamp_ms
+
+      modify_wires = modifies.map do |m|
+        order_wire = build_order_wire(
+          coin: m[:coin],
+          is_buy: m[:is_buy],
+          size: m[:size],
+          limit_px: m[:limit_px],
+          order_type: m[:order_type] || { limit: { tif: 'Gtc' } },
+          reduce_only: m[:reduce_only] || false,
+          cloid: m[:cloid]
+        )
+        { oid: normalize_oid(m[:oid]), order: order_wire }
+      end
+
+      action = {
+        type: 'batchModify',
+        modifies: modify_wires
+      }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Set cross or isolated leverage for a coin
+    # @param coin [String] Asset symbol (perps only)
+    # @param leverage [Integer] Leverage value
+    # @param is_cross [Boolean] True for cross margin, false for isolated (default: true)
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Leverage update response
+    def update_leverage(coin:, leverage:, is_cross: true, vault_address: nil)
+      nonce = timestamp_ms
+
+      action = {
+        type: 'updateLeverage',
+        asset: asset_index(coin),
+        isCross: is_cross,
+        leverage: leverage
+      }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Add or remove isolated margin for a position
+    # @param coin [String] Asset symbol (perps only)
+    # @param amount [Numeric] Amount in USD (positive to add, negative to remove)
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Margin update response
+    def update_isolated_margin(coin:, amount:, vault_address: nil)
+      nonce = timestamp_ms
+
+      action = {
+        type: 'updateIsolatedMargin',
+        asset: asset_index(coin),
+        isBuy: true,
+        ntli: float_to_usd_int(amount)
+      }
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Schedule automatic cancellation of all orders
+    # @param time [Integer, nil] UTC timestamp in milliseconds to cancel at (nil to activate with server default)
+    # @param vault_address [String, nil] Vault address for vault trading (optional)
+    # @return [Hash] Schedule cancel response
+    def schedule_cancel(time: nil, vault_address: nil)
+      nonce = timestamp_ms
+
+      action = { type: 'scheduleCancel' }
+      action[:time] = time if time
+
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        vault_address: vault_address,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, vault_address)
+    end
+
+    # Close a position at market price
+    # @param coin [String] Asset symbol (perps only)
+    # @param size [Numeric, nil] Size to close (nil = close entire position)
+    # @param slippage [Float] Slippage tolerance (default: 5%)
+    # @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 market_close(coin:, size: nil, slippage: DEFAULT_SLIPPAGE, cloid: nil, vault_address: nil)
+      address = vault_address || @signer.address
+      state = @info.user_state(address)
+
+      position = state['assetPositions']&.find do |pos|
+        pos.dig('position', 'coin') == coin
+      end
+      raise ArgumentError, "No open position found for #{coin}" unless position
+
+      szi = position.dig('position', 'szi').to_f
+      is_buy = szi.negative?
+      close_size = size || szi.abs
+
+      mids = @info.all_mids
+      mid = mids[coin]&.to_f
+      raise ArgumentError, "Unknown asset or no price available: #{coin}" unless mid&.positive?
+
+      slippage_price = calculate_slippage_price(coin, mid, is_buy, slippage)
+
+      order(
+        coin: coin,
+        is_buy: is_buy,
+        size: close_size,
+        limit_px: slippage_price,
+        order_type: { limit: { tif: 'Ioc' } },
+        reduce_only: true,
+        cloid: cloid,
+        vault_address: vault_address
+      )
+    end
+
+    # Transfer USDC to another address
+    # @param amount [String, Numeric] Amount to send
+    # @param destination [String] Destination wallet address
+    # @return [Hash] Transfer response
+    def usd_send(amount:, destination:)
+      nonce = timestamp_ms
+      action = {
+        type: 'usdSend',
+        signatureChainId: '0x66eee',
+        hyperliquidChain: Signing::EIP712.hyperliquid_chain(testnet: @signer.instance_variable_get(:@testnet)),
+        destination: destination,
+        amount: amount.to_s,
+        time: nonce
+      }
+      signature = @signer.sign_user_signed_action(
+        { destination: destination, amount: amount.to_s, time: nonce },
+        'HyperliquidTransaction:UsdSend',
+        Signing::EIP712::USD_SEND_TYPES
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Transfer a spot token to another address
+    # @param amount [String, Numeric] Amount to send
+    # @param destination [String] Destination wallet address
+    # @param token [String] Token identifier
+    # @return [Hash] Transfer response
+    def spot_send(amount:, destination:, token:)
+      nonce = timestamp_ms
+      action = {
+        type: 'spotSend',
+        signatureChainId: '0x66eee',
+        hyperliquidChain: Signing::EIP712.hyperliquid_chain(testnet: @signer.instance_variable_get(:@testnet)),
+        destination: destination,
+        token: token,
+        amount: amount.to_s,
+        time: nonce
+      }
+      signature = @signer.sign_user_signed_action(
+        { destination: destination, token: token, amount: amount.to_s, time: nonce },
+        'HyperliquidTransaction:SpotSend',
+        Signing::EIP712::SPOT_SEND_TYPES
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Move USDC between perp and spot accounts
+    # @param amount [String, Numeric] Amount to transfer
+    # @param to_perp [Boolean] True to move to perp, false to move to spot
+    # @return [Hash] Transfer response
+    def usd_class_transfer(amount:, to_perp:)
+      nonce = timestamp_ms
+      action = {
+        type: 'usdClassTransfer',
+        signatureChainId: '0x66eee',
+        hyperliquidChain: Signing::EIP712.hyperliquid_chain(testnet: @signer.instance_variable_get(:@testnet)),
+        amount: amount.to_s,
+        toPerp: to_perp,
+        nonce: nonce
+      }
+      signature = @signer.sign_user_signed_action(
+        { amount: amount.to_s, toPerp: to_perp, nonce: nonce },
+        'HyperliquidTransaction:UsdClassTransfer',
+        Signing::EIP712::USD_CLASS_TRANSFER_TYPES
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Withdraw USDC via the bridge
+    # @param amount [String, Numeric] Amount to withdraw
+    # @param destination [String] Destination wallet address
+    # @return [Hash] Withdrawal response
+    def withdraw_from_bridge(amount:, destination:)
+      nonce = timestamp_ms
+      action = {
+        type: 'withdraw3',
+        signatureChainId: '0x66eee',
+        hyperliquidChain: Signing::EIP712.hyperliquid_chain(testnet: @signer.instance_variable_get(:@testnet)),
+        destination: destination,
+        amount: amount.to_s,
+        time: nonce
+      }
+      signature = @signer.sign_user_signed_action(
+        { destination: destination, amount: amount.to_s, time: nonce },
+        'HyperliquidTransaction:Withdraw',
+        Signing::EIP712::WITHDRAW_TYPES
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Move assets between DEX instances
+    # @param destination [String] Destination wallet address
+    # @param source_dex [String] Source DEX identifier
+    # @param destination_dex [String] Destination DEX identifier
+    # @param token [String] Token identifier
+    # @param amount [String, Numeric] Amount to send
+    # @return [Hash] Transfer response
+    def send_asset(destination:, source_dex:, destination_dex:, token:, amount:)
+      nonce = timestamp_ms
+      action = {
+        type: 'sendAsset',
+        signatureChainId: '0x66eee',
+        hyperliquidChain: Signing::EIP712.hyperliquid_chain(testnet: @signer.instance_variable_get(:@testnet)),
+        destination: destination,
+        sourceDex: source_dex,
+        destinationDex: destination_dex,
+        token: token,
+        amount: amount.to_s,
+        fromSubAccount: '',
+        nonce: nonce
+      }
+      signature = @signer.sign_user_signed_action(
+        {
+          destination: destination, sourceDex: source_dex, destinationDex: destination_dex,
+          token: token, amount: amount.to_s, fromSubAccount: '', nonce: nonce
+        },
+        'HyperliquidTransaction:SendAsset',
+        Signing::EIP712::SEND_ASSET_TYPES
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Create a sub-account
+    # @param name [String] Sub-account name
+    # @return [Hash] Creation response
+    def create_sub_account(name:)
+      nonce = timestamp_ms
+      action = { type: 'createSubAccount', name: name }
+      signature = @signer.sign_l1_action(action, nonce)
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Transfer USDC to/from a sub-account
+    # @param sub_account_user [String] Sub-account wallet address
+    # @param is_deposit [Boolean] True to deposit into sub-account, false to withdraw
+    # @param usd [Numeric] Amount in USD
+    # @return [Hash] Transfer response
+    def sub_account_transfer(sub_account_user:, is_deposit:, usd:)
+      nonce = timestamp_ms
+      action = {
+        type: 'subAccountTransfer',
+        subAccountUser: sub_account_user,
+        isDeposit: is_deposit,
+        usd: float_to_usd_int(usd)
+      }
+      signature = @signer.sign_l1_action(action, nonce)
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Transfer spot tokens to/from a sub-account
+    # @param sub_account_user [String] Sub-account wallet address
+    # @param is_deposit [Boolean] True to deposit into sub-account, false to withdraw
+    # @param token [String] Token identifier
+    # @param amount [String, Numeric] Amount to transfer
+    # @return [Hash] Transfer response
+    def sub_account_spot_transfer(sub_account_user:, is_deposit:, token:, amount:)
+      nonce = timestamp_ms
+      action = {
+        type: 'subAccountSpotTransfer',
+        subAccountUser: sub_account_user,
+        isDeposit: is_deposit,
+        token: token,
+        amount: amount.to_s
+      }
+      signature = @signer.sign_l1_action(action, nonce)
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Deposit or withdraw USDC to/from a vault
+    # @param vault_address [String] Vault wallet address
+    # @param is_deposit [Boolean] True to deposit, false to withdraw
+    # @param usd [Numeric] Amount in USD
+    # @return [Hash] Vault transfer response
+    def vault_transfer(vault_address:, is_deposit:, usd:)
+      nonce = timestamp_ms
+      action = {
+        type: 'vaultTransfer',
+        vaultAddress: vault_address,
+        isDeposit: is_deposit,
+        usd: float_to_usd_int(usd)
+      }
+      signature = @signer.sign_l1_action(action, nonce)
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Set referral code
+    # @param code [String] Referral code
+    # @return [Hash] Set referrer response
+    def set_referrer(code:)
+      nonce = timestamp_ms
+      action = { type: 'setReferrer', code: code }
+      signature = @signer.sign_l1_action(action, nonce)
+      post_action(action, signature, nonce, nil)
+    end
+
     # Clear the asset metadata cache
     # Call this if metadata has been updated
     def reload_metadata!
@@ -345,6 +701,29 @@ module Hyperliquid
       format("%.#{decimal_places}f", rounded)
     end
 
+    # Normalize an order ID to the correct wire format
+    # @param oid [Integer, Cloid, String] Order ID or client order ID
+    # @return [Integer, String] Normalized order ID
+    def normalize_oid(oid)
+      case oid
+      when Integer then oid
+      when Cloid then oid.to_raw
+      when String then normalize_cloid(oid)
+      else raise ArgumentError, "oid must be Integer, Cloid, or String. Got: #{oid.class}"
+      end
+    end
+
+    # Convert a float USD amount to an integer (scaled by 10^6)
+    # @param value [Numeric] USD amount
+    # @return [Integer] Scaled integer value
+    def float_to_usd_int(value)
+      scaled = value.to_f * 1_000_000
+      rounded = scaled.round
+      raise ArgumentError, "float_to_usd_int causes rounding: #{value}" if (rounded - scaled).abs >= 1e-3
+
+      rounded
+    end
+
     # Convert cloid to raw string format
     # @param cloid [Cloid, String, nil] Client order ID
     # @return [String, nil] Raw cloid string

data/lib/hyperliquid/signing/eip712.rb

@@ -12,6 +12,61 @@ module Hyperliquid
       MAINNET_SOURCE = 'a'
       TESTNET_SOURCE = 'b'
 
+      # Chain ID for user-signed actions (Arbitrum Sepolia: 0x66eee = 421614)
+      USER_SIGNED_CHAIN_ID = 421_614
+
+      # EIP-712 type definitions for user-signed actions
+
+      USD_SEND_TYPES = {
+        'HyperliquidTransaction:UsdSend': [
+          { name: :hyperliquidChain, type: 'string' },
+          { name: :destination, type: 'string' },
+          { name: :amount, type: 'string' },
+          { name: :time, type: 'uint64' }
+        ]
+      }.freeze
+
+      SPOT_SEND_TYPES = {
+        'HyperliquidTransaction:SpotSend': [
+          { name: :hyperliquidChain, type: 'string' },
+          { name: :destination, type: 'string' },
+          { name: :token, type: 'string' },
+          { name: :amount, type: 'string' },
+          { name: :time, type: 'uint64' }
+        ]
+      }.freeze
+
+      USD_CLASS_TRANSFER_TYPES = {
+        'HyperliquidTransaction:UsdClassTransfer': [
+          { name: :hyperliquidChain, type: 'string' },
+          { name: :amount, type: 'string' },
+          { name: :toPerp, type: 'bool' },
+          { name: :nonce, type: 'uint64' }
+        ]
+      }.freeze
+
+      WITHDRAW_TYPES = {
+        'HyperliquidTransaction:Withdraw': [
+          { name: :hyperliquidChain, type: 'string' },
+          { name: :destination, type: 'string' },
+          { name: :amount, type: 'string' },
+          { name: :time, type: 'uint64' }
+        ]
+      }.freeze
+
+      SEND_ASSET_TYPES = {
+        'HyperliquidTransaction:SendAsset': [
+          { name: :hyperliquidChain, type: 'string' },
+          { name: :destination, type: 'string' },
+          { name: :sourceDex, type: 'string' },
+          { name: :destinationDex, type: 'string' },
+          { name: :token, type: 'string' },
+          { name: :amount, type: 'string' },
+          { name: :fromSubAccount, type: 'string' },
+          { name: :nonce, type: 'uint64' }
+        ]
+      }.freeze
+
       class << self
         # Domain for L1 actions (orders, cancels, leverage, etc.)
         # @return [Hash] EIP-712 domain configuration
@@ -24,6 +79,17 @@ module Hyperliquid
           }
         end
 
+        # Domain for user-signed actions (transfers, withdrawals, etc.)
+        # @return [Hash] EIP-712 domain configuration
+        def user_signed_domain
+          {
+            name: 'HyperliquidSignTransaction',
+            version: '1',
+            chainId: USER_SIGNED_CHAIN_ID,
+            verifyingContract: '0x0000000000000000000000000000000000000000'
+          }
+        end
+
         # EIP-712 domain type definition
         # @return [Array<Hash>] Domain type fields
         def domain_type
@@ -50,6 +116,13 @@ module Hyperliquid
         def source(testnet:)
           testnet ? TESTNET_SOURCE : MAINNET_SOURCE
         end
+
+        # Get hyperliquid chain name for user-signed actions
+        # @param testnet [Boolean] Whether testnet
+        # @return [String] "Mainnet" or "Testnet"
+        def hyperliquid_chain(testnet:)
+          testnet ? 'Testnet' : 'Mainnet'
+        end
       end
     end
   end

data/lib/hyperliquid/signing/signer.rb

@@ -44,6 +44,31 @@ module Hyperliquid
         sign_typed_data(typed_data)
       end
 
+      # Sign a user-signed action (transfers, withdrawals, etc.)
+      # Uses direct EIP-712 typed data signing with HyperliquidSignTransaction domain
+      # @param action [Hash] The action message to sign (will have chain fields injected)
+      # @param primary_type [String] EIP-712 primary type (e.g., "HyperliquidTransaction:UsdSend")
+      # @param sign_types [Hash] EIP-712 type definitions for the action
+      # @return [Hash] Signature with :r, :s, :v components
+      def sign_user_signed_action(action, primary_type, sign_types)
+        # Inject chain fields into a copy of the action
+        message = action.merge(
+          hyperliquidChain: EIP712.hyperliquid_chain(testnet: @testnet),
+          signatureChainId: '0x66eee'
+        )
+
+        typed_data = {
+          types: {
+            EIP712Domain: EIP712.domain_type
+          }.merge(sign_types),
+          primaryType: primary_type,
+          domain: EIP712.user_signed_domain,
+          message: message
+        }
+
+        sign_typed_data(typed_data)
+      end
+
       private
 
       # Normalize private key format
@@ -54,7 +79,7 @@ module Hyperliquid
       end
 
       # Construct the phantom agent for signing
-      # Maintains parity with Python SDK
+      # Maintains parity with official Python SDK
       # @param action [Hash] Action payload
       # @param nonce [Integer] Nonce timestamp
       # @param vault_address [String, nil] Optional vault address
@@ -62,7 +87,7 @@ module Hyperliquid
       # @return [Hash] Phantom agent with source and connectionId
       def construct_phantom_agent(action, nonce, vault_address, expires_after)
         # Compute action hash
-        # Maintains parity with Python SDK
+        # Maintains parity with official Python SDK
         # data = msgpack(action) + nonce(8 bytes BE) + vault_flag + [vault_addr] + [expires_flag + expires_after]
         # - Note: expires_flag is only included if expires_after exists. A bit odd but that's what the
         #     Python SDK does.

data/lib/hyperliquid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hyperliquid
-  VERSION = '0.4.1'
+  VERSION = '0.6.0'
 end

data/scripts/test_01_spot_market_roundtrip.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Test 1: Spot Market Roundtrip (PURR/USDC)
+# Buy and sell PURR at market price.
+
+require_relative 'test_helpers'
+
+sdk = build_sdk
+separator('TEST 1: Spot Market Roundtrip (PURR/USDC)')
+
+spot_coin = 'PURR/USDC'
+spot_size = 5
+
+mids = sdk.info.all_mids
+spot_price = mids[spot_coin]&.to_f
+
+if spot_price&.positive?
+  puts "#{spot_coin} mid: $#{spot_price}"
+  puts "Size: #{spot_size} PURR (~$#{(spot_size * spot_price).round(2)})"
+  puts "Slippage: #{(SPOT_SLIPPAGE * 100).to_i}%"
+  puts
+
+  puts 'Placing market BUY...'
+  result = sdk.exchange.market_order(
+    coin: spot_coin,
+    is_buy: true,
+    size: spot_size,
+    slippage: SPOT_SLIPPAGE
+  )
+  check_result(result, 'Buy')
+
+  wait_with_countdown(WAIT_SECONDS, 'Waiting before sell...')
+
+  puts 'Placing market SELL...'
+  result = sdk.exchange.market_order(
+    coin: spot_coin,
+    is_buy: false,
+    size: spot_size,
+    slippage: SPOT_SLIPPAGE
+  )
+  check_result(result, 'Sell')
+else
+  puts red("SKIPPED: Could not get #{spot_coin} price")
+end
+
+test_passed('Test 1 Spot Market Roundtrip')
+

data/scripts/test_02_spot_limit_order.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Test 2: Spot Limit Order (Place and Cancel)
+# Place a limit buy well below market, then cancel it.
+
+require_relative 'test_helpers'
+
+sdk = build_sdk
+separator('TEST 2: Spot Limit Order (Place and Cancel)')
+
+spot_coin = 'PURR/USDC'
+spot_size = 5
+
+mids = sdk.info.all_mids
+spot_price = mids[spot_coin]&.to_f
+
+if spot_price&.positive?
+  limit_price = (spot_price * 0.50).round(2)
+  puts "#{spot_coin} mid: $#{spot_price}"
+  puts "Limit price: $#{limit_price} (50% below mid - won't fill)"
+  puts "Size: #{spot_size} PURR"
+  puts
+
+  puts 'Placing limit BUY order...'
+  result = sdk.exchange.order(
+    coin: spot_coin,
+    is_buy: true,
+    size: spot_size,
+    limit_px: limit_price,
+    order_type: { limit: { tif: 'Gtc' } },
+    reduce_only: false
+  )
+  oid = check_result(result, 'Limit order')
+
+  if oid.is_a?(Integer)
+    wait_with_countdown(WAIT_SECONDS, 'Order resting. Waiting before cancel...')
+
+    puts "Canceling order #{oid}..."
+    result = sdk.exchange.cancel(coin: spot_coin, oid: oid)
+    check_result(result, 'Cancel')
+  end
+else
+  puts red("SKIPPED: Could not get #{spot_coin} price")
+end
+
+test_passed('Test 2 Spot Limit Order')
+

data/scripts/test_03_perp_market_roundtrip.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Test 3: Perp Market Roundtrip (BTC Long)
+# Open a long BTC position, then close it.
+
+require_relative 'test_helpers'
+
+sdk = build_sdk
+separator('TEST 3: Perp Market Roundtrip (BTC Long)')
+
+perp_coin = 'BTC'
+mids = sdk.info.all_mids
+btc_price = mids[perp_coin]&.to_f
+
+if btc_price&.positive?
+  meta = sdk.info.meta
+  btc_meta = meta['universe'].find { |a| a['name'] == perp_coin }
+  sz_decimals = btc_meta['szDecimals']
+
+  perp_size = (20.0 / btc_price).ceil(sz_decimals)
+
+  puts "#{perp_coin} mid: $#{btc_price.round(2)}"
+  puts "Size: #{perp_size} BTC (~$#{(perp_size * btc_price).round(2)})"
+  puts "Slippage: #{(PERP_SLIPPAGE * 100).to_i}%"
+  puts
+
+  puts 'Opening LONG position (market buy)...'
+  result = sdk.exchange.market_order(
+    coin: perp_coin,
+    is_buy: true,
+    size: perp_size,
+    slippage: PERP_SLIPPAGE
+  )
+  check_result(result, 'Long open')
+
+  wait_with_countdown(WAIT_SECONDS, 'Position open. Waiting before close...')
+
+  puts 'Closing LONG position (market sell)...'
+  result = sdk.exchange.market_order(
+    coin: perp_coin,
+    is_buy: false,
+    size: perp_size,
+    slippage: PERP_SLIPPAGE
+  )
+  check_result(result, 'Long close')
+else
+  puts red("SKIPPED: Could not get #{perp_coin} price")
+end
+
+test_passed('Test 3 Perp Market Roundtrip')
+