ccxt 4.2.86__py2.py3-none-any.whl → 4.2.88__py2.py3-none-any.whl

ccxt/async_support/gate.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.gate import ImplicitAPI
 import asyncio
 import hashlib
-from ccxt.base.types import Balances, Currency, FundingHistory, Greeks, Int, Leverage, Leverages, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currency, FundingHistory, Greeks, Int, Leverage, Leverages, MarginModification, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -1824,7 +1824,7 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         currency = self.currency(code)
         request = {
-            'currency': currency['id'],
+            'currency': currency['id'],  # todo: currencies have network-junctions
         }
         response = await self.privateWalletGetDepositAddress(self.extend(request, params))
         addresses = self.safe_value(response, 'multichain_addresses')
@@ -1871,7 +1871,7 @@ class gate(Exchange, ImplicitAPI):
         rawNetwork = self.safe_string_upper(params, 'network')
         params = self.omit(params, 'network')
         request = {
-            'currency': currency['id'],
+            'currency': currency['id'],  # todo: currencies have network-junctions
         }
         response = await self.privateWalletGetDepositAddress(self.extend(request, params))
         #
@@ -3346,7 +3346,7 @@ class gate(Exchange, ImplicitAPI):
         currency = None
         if code is not None:
             currency = self.currency(code)
-            request['currency'] = currency['id']
+            request['currency'] = currency['id']  # todo: currencies have network-junctions
         if limit is not None:
             request['limit'] = limit
         if since is not None:
@@ -3378,7 +3378,7 @@ class gate(Exchange, ImplicitAPI):
         currency = None
         if code is not None:
             currency = self.currency(code)
-            request['currency'] = currency['id']
+            request['currency'] = currency['id']  # todo: currencies have network-junctions
         if limit is not None:
             request['limit'] = limit
         if since is not None:
@@ -3405,7 +3405,7 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         currency = self.currency(code)
         request = {
-            'currency': currency['id'],
+            'currency': currency['id'],  # todo: currencies have network-junctions
             'address': address,
             'amount': self.currency_to_precision(code, amount),
         }
@@ -3418,7 +3418,7 @@ class gate(Exchange, ImplicitAPI):
             request['chain'] = network
             params = self.omit(params, 'network')
         else:
-            request['chain'] = currency['id']
+            request['chain'] = currency['id']  # todo: currencies have network-junctions
         response = await self.privateWithdrawalsPostWithdrawals(self.extend(request, params))
         #
         #    {
@@ -4762,7 +4762,7 @@ class gate(Exchange, ImplicitAPI):
         toId = self.convert_type_to_account(toAccount)
         truncated = self.currency_to_precision(code, amount)
         request = {
-            'currency': currency['id'],
+            'currency': currency['id'],  # todo: currencies have network-junctions
             'amount': truncated,
         }
         if not (fromId in self.options['accountsByType']):
@@ -4783,7 +4783,7 @@ class gate(Exchange, ImplicitAPI):
             request['currency_pair'] = market['id']
             params = self.omit(params, 'symbol')
         if (toId == 'futures') or (toId == 'delivery') or (fromId == 'futures') or (fromId == 'delivery'):
-            request['settle'] = currency['id']
+            request['settle'] = currency['id']  # todo: currencies have network-junctions
         response = await self.privateWalletPostTransfers(self.extend(request, params))
         #
         # according to the docs(however actual response seems to be an empty string '')
@@ -5396,7 +5396,7 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         currency = self.currency(code)
         request = {
-            'currency': currency['id'].upper(),
+            'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
         market = self.market(symbol)
@@ -5423,7 +5423,7 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         currency = self.currency(code)
         request = {
-            'currency': currency['id'].upper(),
+            'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
         response = await self.privateMarginPostCrossRepayments(self.extend(request, params))
@@ -5460,7 +5460,7 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         currency = self.currency(code)
         request = {
-            'currency': currency['id'].upper(),
+            'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
         response = None
@@ -5503,7 +5503,7 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         currency = self.currency(code)
         request = {
-            'currency': currency['id'].upper(),
+            'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
         response = await self.privateMarginPostCrossLoans(self.extend(request, params))
@@ -5651,7 +5651,7 @@ class gate(Exchange, ImplicitAPI):
             raise NotSupported(self.id + ' modifyMarginHelper() not support self market type')
         return self.parse_margin_modification(response, market)
 
-    def parse_margin_modification(self, data, market: Market = None):
+    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
         #
         #     {
         #         "value": "11.9257",
@@ -5684,14 +5684,17 @@ class gate(Exchange, ImplicitAPI):
         total = self.safe_number(data, 'margin')
         return {
             'info': data,
-            'amount': None,
-            'code': self.safe_value(market, 'quote'),
             'symbol': market['symbol'],
+            'type': None,
+            'amount': None,
             'total': total,
+            'code': self.safe_value(market, 'quote'),
             'status': 'ok',
+            'timestamp': None,
+            'datetime': None,
         }
 
-    async def reduce_margin(self, symbol: str, amount, params={}):
+    async def reduce_margin(self, symbol: str, amount, params={}) -> MarginModification:
         """
         remove margin from a position
         :see: https://www.gate.io/docs/developers/apiv4/en/#update-position-margin
@@ -5703,7 +5706,7 @@ class gate(Exchange, ImplicitAPI):
         """
         return await self.modify_margin_helper(symbol, -amount, params)
 
-    async def add_margin(self, symbol: str, amount, params={}):
+    async def add_margin(self, symbol: str, amount, params={}) -> MarginModification:
         """
         add margin
         :see: https://www.gate.io/docs/developers/apiv4/en/#update-position-margin
@@ -5993,7 +5996,7 @@ class gate(Exchange, ImplicitAPI):
         if (type == 'spot') or (type == 'margin'):
             if code is not None:
                 currency = self.currency(code)
-                request['currency'] = currency['id']
+                request['currency'] = currency['id']  # todo: currencies have network-junctions
         if (type == 'swap') or (type == 'future'):
             defaultSettle = 'usdt' if (type == 'swap') else 'btc'
             settle = self.safe_string_lower(params, 'settle', defaultSettle)
@@ -6751,7 +6754,7 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         currency = self.currency(code)
         request = {
-            'underlying': currency['code'] + '_USDT',
+            'underlying': currency['code'] + '_USDT',  # todo: currency['id'].upper() &  network junctions
         }
         response = await self.publicOptionsGetContracts(self.extend(request, params))
         #

ccxt/async_support/hitbtc.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.hitbtc import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Leverage, MarginMode, MarginModes, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currency, Int, Leverage, MarginMode, MarginModes, MarginModification, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -1658,7 +1658,7 @@ class hitbtc(Exchange, ImplicitAPI):
             request['from'] = self.iso8601(since)
         request, params = self.handle_until_option('till', request, params)
         if limit is not None:
-            request['limit'] = limit
+            request['limit'] = min(limit, 1000)
         price = self.safe_string(params, 'price')
         params = self.omit(params, 'price')
         response = None
@@ -2999,7 +2999,7 @@ class hitbtc(Exchange, ImplicitAPI):
             'previousFundingDatetime': None,
         }
 
-    async def modify_margin_helper(self, symbol: str, amount, type, params={}):
+    async def modify_margin_helper(self, symbol: str, amount, type, params={}) -> MarginModification:
         await self.load_markets()
         market = self.market(symbol)
         leverage = self.safe_string(params, 'leverage')
@@ -3052,19 +3052,43 @@ class hitbtc(Exchange, ImplicitAPI):
             'type': type,
         })
 
-    def parse_margin_modification(self, data, market: Market = None):
+    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+        #
+        # addMargin/reduceMargin
+        #
+        #     {
+        #         "symbol": "BTCUSDT_PERP",
+        #         "type": "isolated",
+        #         "leverage": "8.00",
+        #         "created_at": "2022-03-30T23:34:27.161Z",
+        #         "updated_at": "2022-03-30T23:34:27.161Z",
+        #         "currencies": [
+        #             {
+        #                 "code": "USDT",
+        #                 "margin_balance": "7.000000000000",
+        #                 "reserved_orders": "0",
+        #                 "reserved_positions": "0"
+        #             }
+        #         ],
+        #         "positions": null
+        #     }
+        #
         currencies = self.safe_value(data, 'currencies', [])
         currencyInfo = self.safe_value(currencies, 0)
+        datetime = self.safe_string(data, 'updated_at')
         return {
             'info': data,
+            'symbol': market['symbol'],
             'type': None,
             'amount': None,
+            'total': None,
             'code': self.safe_string(currencyInfo, 'code'),
-            'symbol': market['symbol'],
             'status': None,
+            'timestamp': self.parse8601(datetime),
+            'datetime': datetime,
         }
 
-    async def reduce_margin(self, symbol: str, amount, params={}):
+    async def reduce_margin(self, symbol: str, amount, params={}) -> MarginModification:
         """
         remove margin from a position
         :see: https://api.hitbtc.com/#create-update-margin-account-2
@@ -3080,7 +3104,7 @@ class hitbtc(Exchange, ImplicitAPI):
             raise BadRequest(self.id + ' reduceMargin() on hitbtc requires the amount to be 0 and that will remove the entire margin amount')
         return await self.modify_margin_helper(symbol, amount, 'reduce', params)
 
-    async def add_margin(self, symbol: str, amount, params={}):
+    async def add_margin(self, symbol: str, amount, params={}) -> MarginModification:
         """
         add margin
         :see: https://api.hitbtc.com/#create-update-margin-account-2

ccxt/async_support/htx.py

@@ -2834,7 +2834,7 @@ class htx(Exchange, ImplicitAPI):
         untilSeconds = self.parse_to_int(until / 1000) if (until is not None) else None
         if market['contract']:
             if limit is not None:
-                request['size'] = limit  # when using limit: from & to are ignored
+                request['size'] = min(limit, 2000)  # when using limit: from & to are ignored
                 # https://huobiapi.github.io/docs/usdt_swap/v1/en/#general-get-kline-data
             else:
                 limit = 2000  # only used for from/to calculation
@@ -2898,7 +2898,7 @@ class htx(Exchange, ImplicitAPI):
             useHistorical, params = self.handle_option_and_params(params, 'fetchOHLCV', 'useHistoricalEndpointForSpot', True)
             if not useHistorical:
                 if limit is not None:
-                    request['size'] = min(2000, limit)  # max 2000
+                    request['size'] = min(limit, 2000)  # max 2000
                 response = await self.spotPublicGetMarketHistoryKline(self.extend(request, params))
             else:
                 # "from & to" only available for the self endpoint

ccxt/async_support/huobijp.py

@@ -927,7 +927,7 @@ class huobijp(Exchange, ImplicitAPI):
             'period': self.safe_string(self.timeframes, timeframe, timeframe),
         }
         if limit is not None:
-            request['size'] = limit
+            request['size'] = min(limit, 2000)
         response = await self.marketGetHistoryKline(self.extend(request, params))
         #
         #     {

ccxt/async_support/hyperliquid.py

@@ -5,7 +5,8 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.hyperliquid import ImplicitAPI
-from ccxt.base.types import Balances, Int, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Trade, TransferEntry
+import asyncio
+from ccxt.base.types import Balances, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Trade, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -32,7 +33,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'pro': True,
             'has': {
                 'CORS': None,
-                'spot': False,
+                'spot': True,
                 'margin': False,
                 'swap': True,
                 'future': True,
@@ -165,6 +166,10 @@ class hyperliquid(Exchange, ImplicitAPI):
                     'taker': self.parse_number('0.00035'),
                     'maker': self.parse_number('0.0001'),
                 },
+                'spot': {
+                    'taker': self.parse_number('0.00035'),
+                    'maker': self.parse_number('0.0001'),
+                },
             },
             'requiredCredentials': {
                 'apiKey': False,
@@ -192,6 +197,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'commonCurrencies': {
             },
             'options': {
+                'defaultType': 'swap',
                 'sandboxMode': False,
                 'defaultSlippage': 0.05,
                 'zeroAddress': '0x0000000000000000000000000000000000000000',
@@ -257,6 +263,22 @@ class hyperliquid(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
+        rawPromises = [
+            self.fetch_swap_markets(params),
+            self.fetch_spot_markets(params),
+        ]
+        promises = await asyncio.gather(*rawPromises)
+        swapMarkets = promises[0]
+        spotMarkets = promises[1]
+        return self.array_concat(swapMarkets, spotMarkets)
+
+    async def fetch_swap_markets(self, params={}) -> List[Market]:
+        """
+        retrieves data on all swap markets for hyperliquid
+        :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-asset-contexts-includes-mark-price-current-funding-open-interest-etc
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: an array of objects representing market data
+        """
         request = {
             'type': 'metaAndAssetCtxs',
         }
@@ -304,6 +326,129 @@ class hyperliquid(Exchange, ImplicitAPI):
             result.append(data)
         return self.parse_markets(result)
 
+    async def fetch_spot_markets(self, params={}) -> List[Market]:
+        """
+        retrieves data on all spot markets for hyperliquid
+        :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-asset-contexts-includes-mark-price-current-funding-open-interest-etc
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: an array of objects representing market data
+        """
+        request = {
+            'type': 'spotMetaAndAssetCtxs',
+        }
+        response = await self.publicPostInfo(self.extend(request, params))
+        #
+        # [
+        #     {
+        #         'tokens': [
+        #             {
+        #                 'name': 'USDC',
+        #                 'szDecimals': '8',
+        #                 'weiDecimals': '8',
+        #             },
+        #             {
+        #                 'name': 'PURR',
+        #                 'szDecimals': '0',
+        #                 'weiDecimals': '5',
+        #             },
+        #         ],
+        #         'universe': [
+        #             {
+        #                 'name': 'PURR/USDC',
+        #                 'tokens': [
+        #                     1,
+        #                     0,
+        #                 ],
+        #             },
+        #         ],
+        #     },
+        #     [
+        #         {
+        #             'dayNtlVlm': '264250385.14640012',
+        #             'markPx': '0.018314',
+        #             'midPx': '0.0182235',
+        #             'prevDayPx': '0.017427',
+        #         },
+        #     ],
+        # ]
+        #
+        first = self.safe_dict(response, 0, {})
+        meta = self.safe_list(first, 'universe', [])
+        tokens = self.safe_list(first, 'tokens', [])
+        markets = []
+        for i in range(0, len(meta)):
+            market = self.safe_dict(meta, i, {})
+            marketName = self.safe_string(market, 'name')
+            marketParts = marketName.split('/')
+            baseName = self.safe_string(marketParts, 0)
+            quoteId = self.safe_string(marketParts, 1)
+            base = self.safe_currency_code(baseName)
+            quote = self.safe_currency_code(quoteId)
+            symbol = base + '/' + quote
+            fees = self.safe_dict(self.fees, 'spot', {})
+            taker = self.safe_number(fees, 'taker')
+            maker = self.safe_number(fees, 'maker')
+            tokensPos = self.safe_list(market, 'tokens', [])
+            baseTokenPos = self.safe_integer(tokensPos, 0)
+            quoteTokenPos = self.safe_integer(tokensPos, 1)
+            baseTokenInfo = self.safe_dict(tokens, baseTokenPos, {})
+            quoteTokenInfo = self.safe_dict(tokens, quoteTokenPos, {})
+            baseDecimals = self.safe_string(baseTokenInfo, 'szDecimals')
+            quoteDecimals = self.safe_integer(quoteTokenInfo, 'szDecimals')
+            baseId = self.number_to_string(i + 10000)
+            markets.append(self.safe_market_structure({
+                'id': baseId,
+                'symbol': symbol,
+                'base': base,
+                'quote': quote,
+                'settle': None,
+                'baseId': baseId,
+                'quoteId': quoteId,
+                'settleId': None,
+                'type': 'spot',
+                'spot': True,
+                'margin': None,
+                'swap': False,
+                'future': False,
+                'option': False,
+                'active': True,
+                'contract': False,
+                'linear': True,
+                'inverse': False,
+                'taker': taker,
+                'maker': maker,
+                'contractSize': None,
+                'expiry': None,
+                'expiryDatetime': None,
+                'strike': None,
+                'optionType': None,
+                'precision': {
+                    'amount': self.parse_number(self.parse_precision(baseDecimals)),  # decimal places
+                    'price': quoteDecimals,  # significant digits
+                },
+                'limits': {
+                    'leverage': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'price': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'cost': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'created': None,
+                'info': market,
+            }))
+        return markets
+
     def parse_market(self, market) -> Market:
         #
         #     {
@@ -398,12 +543,17 @@ class hyperliquid(Exchange, ImplicitAPI):
         :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-state
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.user]: user address, will default to self.walletAddress if not provided
+        :param str [params.type]: wallet type, ['spot', 'swap'], defaults to swap
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
         userAddress = None
         userAddress, params = self.handle_public_address('fetchBalance', params)
+        type = None
+        type, params = self.handle_market_type_and_params('fetchBalance', None, params)
+        isSpot = (type == 'spot')
+        reqType = 'spotClearinghouseState' if (isSpot) else 'clearinghouseState'
         request = {
-            'type': 'clearinghouseState',
+            'type': reqType,
             'user': userAddress,
         }
         response = await self.publicPostInfo(self.extend(request, params))
@@ -426,7 +576,35 @@ class hyperliquid(Exchange, ImplicitAPI):
         #         "time": "1704261007014",
         #         "withdrawable": "100.0"
         #     }
+        # spot
+        #
+        #     {
+        #         "balances":[
+        #            {
+        #               "coin":"USDC",
+        #               "hold":"0.0",
+        #               "total":"1481.844"
+        #            },
+        #            {
+        #               "coin":"PURR",
+        #               "hold":"0.0",
+        #               "total":"999.65004"
+        #            }
+        #     }
         #
+        balances = self.safe_list(response, 'balances')
+        if balances is not None:
+            spotBalances = {'info': response}
+            for i in range(0, len(balances)):
+                balance = balances[i]
+                code = self.safe_currency_code(self.safe_string(balance, 'coin'))
+                account = self.account()
+                total = self.safe_string(balance, 'total')
+                free = self.safe_string(balance, 'hold')
+                account['total'] = total
+                account['free'] = free
+                spotBalances[code] = account
+            return self.safe_balance(spotBalances)
         data = self.safe_dict(response, 'marginSummary', {})
         result = {
             'info': response,
@@ -915,6 +1093,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.clientOrderId]: client order id,(optional 128 bit hex string e.g. 0x1234567890abcdef1234567890abcdef)
+        :param str [params.vaultAddress]: the vault address for order
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         return await self.cancel_orders([id], symbol, params)
@@ -928,6 +1107,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         :param str [symbol]: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param string|str[] [params.clientOrderId]: client order ids,(optional 128 bit hex string e.g. 0x1234567890abcdef1234567890abcdef)
+        :param str [params.vaultAddress]: the vault address
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.check_required_credentials()
@@ -1377,7 +1557,10 @@ class hyperliquid(Exchange, ImplicitAPI):
         coin = self.safe_string(entry, 'coin')
         marketId = None
         if coin is not None:
-            marketId = coin + '/USDC:USDC'
+            if coin.find('/') > -1:
+                marketId = coin
+            else:
+                marketId = coin + '/USDC:USDC'
         if self.safe_string(entry, 'id') is None:
             market = self.safe_market(marketId, None)
         else:
@@ -1772,7 +1955,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         #
         return response
 
-    async def add_margin(self, symbol: str, amount, params={}):
+    async def add_margin(self, symbol: str, amount, params={}) -> MarginModification:
         """
         add margin
         :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-isolated-margin
@@ -1783,7 +1966,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         """
         return await self.modify_margin_helper(symbol, amount, 'add', params)
 
-    async def reduce_margin(self, symbol: str, amount, params={}):
+    async def reduce_margin(self, symbol: str, amount, params={}) -> MarginModification:
         """
         :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-isolated-margin
         remove margin from a position
@@ -1794,7 +1977,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         """
         return await self.modify_margin_helper(symbol, amount, 'reduce', params)
 
-    async def modify_margin_helper(self, symbol: str, amount, type, params={}):
+    async def modify_margin_helper(self, symbol: str, amount, type, params={}) -> MarginModification:
         await self.load_markets()
         market = self.market(symbol)
         asset = self.parse_to_int(market['baseId'])
@@ -1828,10 +2011,27 @@ class hyperliquid(Exchange, ImplicitAPI):
         #         'status': 'ok'
         #     }
         #
-        return response
-        # return self.extend(self.parse_margin_modification(response, market), {
-        #     'code': code,
-        # })
+        return self.extend(self.parse_margin_modification(response, market), {
+            'code': self.safe_string(response, 'status'),
+        })
+
+    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+        #
+        #    {
+        #        'type': 'default'
+        #    }
+        #
+        return {
+            'info': data,
+            'symbol': self.safe_symbol(None, market),
+            'type': None,
+            'amount': None,
+            'total': None,
+            'code': self.safe_string(market, 'settle'),
+            'status': None,
+            'timestamp': None,
+            'datetime': None,
+        }
 
     async def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
@@ -1839,23 +2039,49 @@ class hyperliquid(Exchange, ImplicitAPI):
         :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#l1-usdc-transfer
         :param str code: unified currency code
         :param float amount: amount to transfer
-        :param str fromAccount: account to transfer from
-        :param str toAccount: account to transfer to
+        :param str fromAccount: account to transfer from *spot, swap*
+        :param str toAccount: account to transfer to *swap, spot or address*
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.vaultAddress]: the vault address for order
         :returns dict: a `transfer structure <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         self.check_required_credentials()
         await self.load_markets()
+        isSandboxMode = self.safe_bool(self.options, 'sandboxMode')
+        nonce = self.milliseconds()
+        if self.in_array(fromAccount, ['spot', 'swap', 'perp']):
+            # handle swap <> spot account transfer
+            if not self.in_array(toAccount, ['spot', 'swap', 'perp']):
+                raise NotSupported(self.id + 'transfer() only support spot <> swap transfer')
+            vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
+            params = self.omit(params, 'vaultAddress')
+            toPerp = (toAccount == 'perp') or (toAccount == 'swap')
+            action = {
+                'type': 'spotUser',
+                'classTransfer': {
+                    'usdc': amount,
+                    'toPerp': toPerp,
+                },
+            }
+            signature = self.sign_l1_action(action, nonce, vaultAddress)
+            innerRequest = {
+                'action': self.extend(action, params),
+                'nonce': nonce,
+                'signature': signature,
+            }
+            if vaultAddress is not None:
+                innerRequest['vaultAddress'] = vaultAddress
+            transferResponse = await self.privatePostExchange(innerRequest)
+            return transferResponse
+        # handle sub-account/different account transfer
         self.check_address(toAccount)
         if code is not None:
             code = code.upper()
             if code != 'USDC':
                 raise NotSupported(self.id + 'withdraw() only support USDC')
-        isSandboxMode = self.safe_bool(self.options, 'sandboxMode')
-        nonce = self.milliseconds()
         payload = {
             'destination': toAccount,
-            'amount': str(amount),
+            'amount': self.number_to_string(amount),
             'time': nonce,
         }
         sig = self.build_transfer_sig(payload)