hyperliquid 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4e2d29336f0e921d82f0f7a154676a102a228fd5aa4811b85db890802330865
-  data.tar.gz: ff28b26c30bd14549def4e1f5adb3193ab812cc4527da50109dd17d5bc333816
+  metadata.gz: 324ff762cbf5edcea7fc532f853b7295ffcd34476f6273fdef4e03bcc0f9eaee
+  data.tar.gz: 98b1b88b378bb8ae010301c656c833282cd406822fa0c8a7d6c134911b0f2cce
 SHA512:
-  metadata.gz: d19f8ddf0b9d7cb16a7791a2d7117725929e956c05a46a27b11cc9b27bb051f0c4d7b1cfc1053e3683a9577ceaacbd96ebd3b06a3541d527f9c0437e5de067b1
-  data.tar.gz: 8a590a96b1e14b8178e3d628cb8e498d718e0a41963dad0671ead93c06df3d389e2fe2c3082d2a27965eb0adf46370e1508f8a9b0cb2e002444c225e39d8aa79
+  metadata.gz: fe9e447e5500312f98e8f8e602071372847963daacfd51475e92d4db5a7bc988546e4cf106479a9c899bcecf113612c2aa9ebe0dd50a5384bd438bb0d6429865
+  data.tar.gz: 7cd7d2e048c4bf25e128dd7fd41814621bd95305d613199cb4c41abdf1901fdc4c665635000112aafeb7c395dbf01dae81cba74042557d86643c6ac169e3d201

data/.rubocop.yml

@@ -4,6 +4,7 @@ AllCops:
   SuggestExtensions: false
   Exclude:
     - 'test_*.rb'  # Exclude ad-hoc integration test scripts
+    - 'scripts/**/*'  # Exclude integration test scripts
     - 'vendor/**/*'  # Exclude vendored gems (CI bundles here)
 
 # Allow longer methods for complex logic

data/CHANGELOG.md

@@ -1,8 +1,20 @@
 ## [Ruby Hyperliquid SDK Changelog]
 
+## [0.6.0] - 2026-01-28
+
+- Add transfers and account management to Exchange API
+  - USD transfers: `usd_send`, `usd_class_transfer`, `withdraw_from_bridge`
+  - Spot transfers: `spot_send`, `send_asset`
+  - Sub-accounts: `create_sub_account`, `sub_account_transfer`, `sub_account_spot_transfer`
+  - Vaults: `vault_transfer`
+  - Referrals: `set_referrer`
+- Add user-signed action signing (`sign_user_signed_action`) for EIP-712 typed data with `HyperliquidSignTransaction` domain
+- Add Python SDK parity test vectors for `usd_send`, `withdraw_from_bridge`, `create_sub_account`, and `sub_account_transfer`
+- Reorganize integration tests into individual scripts under `scripts/` for easier debugging
+
 ## [0.5.0] - 2026-01-28
 
-- Add core trading features to Exchange API (Tier 1 parity with Python SDK)
+- Add core trading features to Exchange API
   - Order modification: `modify_order`, `batch_modify`
   - Position management: `update_leverage`, `update_isolated_margin`, `market_close`
   - Dead man's switch: `schedule_cancel`

data/CLAUDE.md

@@ -45,16 +45,15 @@ ruby example.rb
 
 ### Integration Testing (Testnet)
 ```bash
-# Run the testnet integration test (requires private key)
+# Run all integration tests (requires private key)
 # Get testnet funds from: https://app.hyperliquid-testnet.xyz
-HYPERLIQUID_PRIVATE_KEY=0x... ruby test_integration.rb
+HYPERLIQUID_PRIVATE_KEY=0x... ruby scripts/test_all.rb
+
+# Run a single integration test
+HYPERLIQUID_PRIVATE_KEY=0x... ruby scripts/test_08_usd_class_transfer.rb
 ```
 
-The integration test executes real trades on testnet:
-1. Spot market roundtrip (buy/sell PURR/USDC)
-2. Spot limit order (place and cancel)
-3. Perp market roundtrip (long/close BTC)
-4. Perp limit order (place short, cancel)
+Integration tests live in `scripts/` as individual files. Each can be run standalone for debugging. `test_integration.rb` at the project root is a convenience wrapper that runs them all.
 
 ### Setup
 ```bash

data/docs/API.md

@@ -84,11 +84,24 @@ Read-only methods for querying market data and user information.
 - `update_leverage(coin:, leverage:, is_cross:, ...)` - Set cross or isolated leverage for a coin
 - `update_isolated_margin(coin:, amount:, ...)` - Add or remove isolated margin for a position
 
+### Transfers & Account Management
+
+- `usd_send(amount:, destination:)` - Transfer USDC to another address
+- `spot_send(amount:, destination:, token:)` - Transfer a spot token to another address
+- `usd_class_transfer(amount:, to_perp:)` - Move USDC between perp and spot accounts
+- `withdraw_from_bridge(amount:, destination:)` - Withdraw USDC via the bridge
+- `send_asset(destination:, source_dex:, destination_dex:, token:, amount:)` - Move assets between DEX instances
+- `create_sub_account(name:)` - Create a sub-account
+- `sub_account_transfer(sub_account_user:, is_deposit:, usd:)` - Transfer USDC to/from a sub-account
+- `sub_account_spot_transfer(sub_account_user:, is_deposit:, token:, amount:)` - Transfer spot tokens to/from a sub-account
+- `vault_transfer(vault_address:, is_deposit:, usd:)` - Deposit or withdraw USDC to/from a vault
+- `set_referrer(code:)` - Set referral code
+
 ### Other
 
 - `address` - Get the wallet address associated with the private key
 
-All exchange methods support an optional `vault_address:` parameter for vault trading.
+Order placement and management methods support an optional `vault_address:` parameter for vault trading.
 
 ### Order Types
 

data/docs/DEVELOPMENT.md

@@ -11,13 +11,42 @@ bin/setup
 ## Running Tests
 
 ```bash
-# Run all tests
+# Run all unit tests
 rake spec
 
-# Run tests and linting together (default)
+# Run unit tests and linting together (default)
 rake
 ```
 
+### Integration Testing (Testnet)
+
+Integration tests live in `scripts/` and execute real trades on testnet. No real funds are at risk. Get testnet funds from https://app.hyperliquid-testnet.xyz.
+
+```bash
+# Run all integration tests
+HYPERLIQUID_PRIVATE_KEY=0x... ruby scripts/test_all.rb
+
+# Run a single integration test
+HYPERLIQUID_PRIVATE_KEY=0x... ruby scripts/test_08_usd_class_transfer.rb
+```
+
+The convenience wrapper `ruby test_integration.rb` also runs all tests.
+
+Available test scripts:
+
+| Script | Description |
+|--------|-------------|
+| `test_01_spot_market_roundtrip.rb` | Buy/sell PURR/USDC at market |
+| `test_02_spot_limit_order.rb` | Place and cancel a spot limit order |
+| `test_03_perp_market_roundtrip.rb` | Long/close BTC at market |
+| `test_04_perp_limit_order.rb` | Place and cancel a perp short |
+| `test_05_update_leverage.rb` | Set cross, isolated, and reset leverage |
+| `test_06_modify_order.rb` | Place, modify, and cancel an order |
+| `test_07_market_close.rb` | Open a position and close via `market_close` |
+| `test_08_usd_class_transfer.rb` | Transfer USDC between perp and spot |
+| `test_09_sub_account_lifecycle.rb` | Create sub-account, deposit, withdraw |
+| `test_10_vault_transfer.rb` | Deposit/withdraw to a vault |
+
 ## Linting
 
 ```bash
@@ -37,18 +66,3 @@ This opens an interactive prompt with the SDK loaded for experimentation.
 ```bash
 ruby example.rb
 ```
-
-## Integration Testing (Testnet)
-
-For real trading tests on testnet:
-
-```bash
-# Get testnet funds from: https://app.hyperliquid-testnet.xyz
-HYPERLIQUID_PRIVATE_KEY=0x... ruby test_integration.rb
-```
-
-The integration test executes real trades on testnet:
-1. Spot market roundtrip (buy/sell PURR/USDC)
-2. Spot limit order (place and cancel)
-3. Perp market roundtrip (long/close BTC)
-4. Perp limit order (place short, cancel)

data/docs/EXAMPLES.md

@@ -388,6 +388,97 @@ sdk.exchange.order(
 )
 ```
 
+### Transfers & Account Management
+
+```ruby
+# Transfer USDC to another address
+sdk.exchange.usd_send(
+  amount: '100',
+  destination: '0x...'
+)
+
+# Transfer a spot token to another address
+sdk.exchange.spot_send(
+  amount: '50',
+  destination: '0x...',
+  token: 'PURR'
+)
+
+# Move USDC between perp and spot accounts
+sdk.exchange.usd_class_transfer(amount: '100', to_perp: false)   # perp -> spot
+sdk.exchange.usd_class_transfer(amount: '100', to_perp: true)    # spot -> perp
+
+# Withdraw USDC via the bridge
+sdk.exchange.withdraw_from_bridge(
+  amount: '100',
+  destination: '0x...'
+)
+
+# Move assets between DEX instances
+sdk.exchange.send_asset(
+  destination: '0x...',
+  source_dex: 'dex1',
+  destination_dex: 'dex2',
+  token: 'USDC',
+  amount: '100'
+)
+```
+
+### Sub-Account Management
+
+```ruby
+# Create a sub-account
+result = sdk.exchange.create_sub_account(name: 'my-sub-account')
+sub_address = result.dig('response', 'data', 'subAccountUser')
+
+# Deposit USDC into a sub-account
+sdk.exchange.sub_account_transfer(
+  sub_account_user: sub_address,
+  is_deposit: true,
+  usd: 100
+)
+
+# Withdraw USDC from a sub-account
+sdk.exchange.sub_account_transfer(
+  sub_account_user: sub_address,
+  is_deposit: false,
+  usd: 50
+)
+
+# Transfer spot tokens to a sub-account
+sdk.exchange.sub_account_spot_transfer(
+  sub_account_user: sub_address,
+  is_deposit: true,
+  token: 'PURR',
+  amount: '10'
+)
+```
+
+### Vault Operations
+
+```ruby
+# Deposit USDC into a vault
+sdk.exchange.vault_transfer(
+  vault_address: '0x...',
+  is_deposit: true,
+  usd: 100
+)
+
+# Withdraw USDC from a vault
+sdk.exchange.vault_transfer(
+  vault_address: '0x...',
+  is_deposit: false,
+  usd: 50
+)
+```
+
+### Referral
+
+```ruby
+# Set a referral code
+sdk.exchange.set_referrer(code: 'MY_REFERRAL_CODE')
+```
+
 ### Client Order IDs (Cloid)
 
 ```ruby

data/lib/hyperliquid/exchange.rb

@@ -374,6 +374,201 @@ module Hyperliquid
       )
     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!

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.5.0'
+  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')
+