Version 0.9.0

Author: traderben

examples/basic_builder_fee.py

@@ -10,12 +10,12 @@ def main():
         raise Exception("Only the main wallet has permission to approve a builder fee")
 
     # approve setting a builder fee
-    approve_result = exchange.approve_builder_fee("0x0000000000000000000000000000000000000000", "0.001%")
+    approve_result = exchange.approve_builder_fee("0x8c967E73E7B15087c42A10D344cFf4c96D877f1D", "0.001%")
     print(approve_result)
 
     # place an order with builder set, this will cause an additional fee to be added to the order which is sent to the builder
     order_result = exchange.market_open(
-        "ETH", True, 0.05, None, 0.01, builder={"b": "0x0000000000000000000000000000000000000000", "f": 1}
+        "ETH", True, 0.05, None, 0.01, builder={"b": "0x8c967E73E7B15087c42A10D344cFf4c96D877f1D", "f": 1}
     )
     print(order_result)
 

examples/basic_convert_to_multi_sig_user.py

@@ -8,8 +8,10 @@ def main():
     if exchange.account_address != exchange.wallet.address:
         raise Exception("Agents do not have permission to convert to multi-sig user")
 
-    # authorized users are the users for which one can themselves or agents use as signers
-    # for multi-sig actions
+    # Authorized users are the public addresses of the wallets that will be able to sign on behalf of the multi-sig user.
+    # Some additional notes:
+    # Only existing users may be used. In other words, the authorized users must have deposited. Otherwise this conversion will fail.
+    # The multi-sig signatures must be generated by the authorized user's wallet. Agent/API wallets cannot be used.
     authorized_user_1 = "0x0000000000000000000000000000000000000000"
     authorized_user_2 = "0x0000000000000000000000000000000000000001"
     threshold = 1

examples/basic_multi_sig.py

@@ -1,5 +1,5 @@
 from hyperliquid.utils import constants
-from hyperliquid.utils.signing import sign_usd_transfer_action, get_timestamp_ms
+from hyperliquid.utils.signing import get_timestamp_ms, sign_multi_sig_inner, USD_SEND_SIGN_TYPES
 from hyperliquid.utils.types import Any, List
 import example_utils
 
@@ -8,9 +8,16 @@ def main():
     address, info, exchange = example_utils.setup(constants.TESTNET_API_URL, skip_ws=True)
     multi_sig_wallets = example_utils.setup_multi_sig_wallets()
 
+    # The outer signer is required to be an authorized user or an agent of the authorized user of the multi-sig user.
+
+    # Address of the multi-sig user that the action will be executed for
+    # Executing the action requires at least the specified threshold of signatures
+    # required for that multi-sig user
     multi_sig_user = "0x0000000000000000000000000000000000000005"
 
     timestamp = get_timestamp_ms()
+
+    # Define the multi-sig inner action - in this case, sending USD
     action = {
         "type": "usdSend",
         "signatureChainId": "0x66eee",
@@ -20,10 +27,23 @@ def main():
         "time": timestamp,
     }
     signatures: List[Any] = []
+
+    # Collect signatures from each wallet in multi_sig_wallets. Each wallet must belong to a user.
     for wallet in multi_sig_wallets:
-        signature = sign_usd_transfer_action(wallet, action, False)
+        # Sign the action with each wallet
+        signature = sign_multi_sig_inner(
+            wallet,
+            action,
+            exchange.base_url == constants.MAINNET_API_URL,
+            USD_SEND_SIGN_TYPES,
+            "HyperliquidTransaction:UsdSend",
+            multi_sig_user,
+            address,
+        )
         signatures.append(signature)
 
+    # Execute the multi-sig action with all collected signatures
+    # This will only succeed if enough valid signatures are provided
     multi_sig_result = exchange.multi_sig(multi_sig_user, action, signatures, timestamp)
     print(multi_sig_result)
 

examples/config.json.example

@@ -5,7 +5,24 @@
         If you are using an Agent/API Wallet you MUST also specify the public address of your account, not the
         address of the Agent/API Wallet.
         Otherwise, feel free to leave it blank and it will be automatically derived from the secret key.
+
+        You can also populate the "multi_sig" section with the secret keys of the authorized user wallets that you
+        wish to sign multi-sig actions for.
     ",
     "secret_key": "",
-    "account_address": ""
-}
+    "account_address": "",
+    "multi_sig": {
+        "authorized_users": [
+            {
+                "comment": "signer 1",
+                "secret_key": "",
+                "account_address": ""
+            },
+            {
+                "comment": "signer 2",
+                "secret_key": "",
+                "account_address": ""
+            }
+        ]
+    }
+}

examples/example_utils.py

@@ -33,15 +33,16 @@ def setup(base_url=None, skip_ws=False):
 
 
 def setup_multi_sig_wallets():
-    config_path = os.path.join(os.path.dirname(__file__), "multi_sig_wallets.json")
+    config_path = os.path.join(os.path.dirname(__file__), "config.json")
     with open(config_path) as f:
         config = json.load(f)
-    wallets = []
-    for wallet_config in config:
+
+    authorized_user_wallets = []
+    for wallet_config in config["multi_sig"]["authorized_users"]:
         account: LocalAccount = eth_account.Account.from_key(wallet_config["secret_key"])
         address = wallet_config["account_address"]
         if account.address != address:
-            raise Exception(f"provided signer address {address} does not match private key")
-        print("loaded multi-sig signer", address)
-        wallets.append(account)
-    return wallets
+            raise Exception(f"provided authorized user address {address} does not match private key")
+        print("loaded authorized user for multi-sig", address)
+        authorized_user_wallets.append(account)
+    return authorized_user_wallets

hyperliquid/exchange.py

@@ -29,7 +29,7 @@
     sign_usd_transfer_action,
     sign_withdraw_from_bridge_action,
     sign_convert_to_multi_sig_user_action,
-    sign_convert_to_multi_sig_signer_action,
+    sign_multi_sig_action,
 )
 from hyperliquid.utils.types import Any, BuilderInfo, Cloid, List, Meta, Optional, SpotMeta, Tuple
 
@@ -112,6 +112,8 @@ def bulk_orders(self, order_requests: List[OrderRequest], builder: Optional[Buil
         ]
         timestamp = get_timestamp_ms()
 
+        if builder:
+            builder["b"] = builder["b"].lower()
         order_action = order_wires_to_order_action(order_wires, builder)
 
         signature = sign_l1_action(
@@ -572,36 +574,26 @@ def convert_to_multi_sig_user(self, authorized_users: List[str], threshold: int)
             timestamp,
         )
 
-    def convert_to_multi_sig_signer(self, signer: str, multi_sig_user: str) -> Any:
-        timestamp = get_timestamp_ms()
-        action = {
-            "type": "convertToMultiSigUser",
-            "signer": signer,
-            "multi_sig_user": multi_sig_user,
-            "nonce": timestamp,
-        }
-        signature = sign_convert_to_multi_sig_signer_action(self.wallet, action, self.base_url == MAINNET_API_URL)
-        return self._post_action(
-            action,
-            signature,
-            timestamp,
-        )
-
     def multi_sig(self, multi_sig_user, inner_action, signatures, nonce, vault_address=None):
+        multi_sig_user = multi_sig_user.lower()
         multi_sig_action = {
             "type": "multiSig",
-            "user": multi_sig_user.lower(),
+            "signatureChainId": "0x66eee",
             "signatures": signatures,
-            "inner": inner_action,
+            "payload": {
+                "multiSigUser": multi_sig_user,
+                "outerSigner": self.wallet.address.lower(),
+                "action": inner_action,
+            },
         }
-        signature = sign_l1_action(
+        is_mainnet = self.base_url == MAINNET_API_URL
+        signature = sign_multi_sig_action(
             self.wallet,
             multi_sig_action,
+            is_mainnet,
             vault_address,
             nonce,
-            self.base_url == MAINNET_API_URL,
         )
-
         return self._post_action(
             multi_sig_action,
             signature,

hyperliquid/info.py

@@ -216,7 +216,9 @@ def user_fills_by_time(self, address: str, start_time: int, end_time: Optional[i
               ...
             ]
         """
-        return self.post("/info", {"type": "userFillsByTime", "user": address, "startTime": start_time, "endTime": end_time})
+        return self.post(
+            "/info", {"type": "userFillsByTime", "user": address, "startTime": start_time, "endTime": end_time}
+        )
 
     def meta(self) -> Meta:
         """Retrieve exchange perp metadata
@@ -506,9 +508,6 @@ def query_sub_accounts(self, user: str) -> Any:
     def query_user_to_multi_sig_signers(self, multi_sig_user: str) -> Any:
         return self.post("/info", {"type": "userToMultiSigSigners", "user": multi_sig_user})
 
-    def query_signer_to_multi_sig_user(self, signer: str) -> Any:
-        return self.post("/info", {"type": "signerToMultiSigUser", "signer": signer})
-
     def subscribe(self, subscription: Subscription, callback: Callable[[Any], None]) -> int:
         if subscription["type"] == "l2Book" or subscription["type"] == "trades" or subscription["type"] == "candle":
             subscription["coin"] = self.name_to_coin[subscription["coin"]]