Always derive wallet address from private key (#35)

* Always derive wallet address from private key

* linting

* linting

* linting

* distinguish between owner and signer wallets

* fixes

* chore: bump SDK version to 2.0.6.1

---------

Co-authored-by: GitHub Action <action@github.com>

Author: danigr99727

.env.example

@@ -5,18 +5,20 @@ REYA_WS_URL=
 PRIVATE_KEY=
 ACCOUNT_ID=
 CHAIN_ID= # 1729 mainnet and 89346162 cronos
-WALLET_ADDRESS=
+
+# The wallet address that owns ACCOUNT_ID
+OWNER_WALLET_ADDRESS=
 
 ### Reya Cronos (testnet) example
 ACCOUNT_ID=replaceme
 PRIVATE_KEY=replacemereplacemereplacemereplacemereplacemereplacemereplaceme
 CHAIN_ID=89346162
 REYA_WS_URL="wss://websocket-testnet.reya.xyz/"
-WALLET_ADDRESS=replaceme
+OWMNER_WALLET_ADDRESS=replaceme
 
 ### Reya Network (mainnet) example
 ACCOUNT_ID=replaceme
 PRIVATE_KEY=replacemereplacemereplacemereplacemereplacemereplacemereplaceme
 CHAIN_ID=1729
 REYA_WS_URL="wss://ws.reya.xyz/"
-WALLET_ADDRESS=replaceme
+OWNER_WALLET_ADDRESS=replaceme

README.md

@@ -167,8 +167,17 @@ PRIVATE_KEY=your_private_key
 CHAIN_ID=1729                   # Use 89346162 for testnet
 REYA_WS_URL=wss://ws.reya.xyz/  # Use wss://websocket-testnet.reya.xyz/ for testnet
 REYA_API_BASE_URL=https://api.reya.xyz/v2  # Use https://api-test.reya.xyz/v2 for testnet
-WALLET_ADDRESS=your_wallet_address
+OWNER_WALLET_ADDRESS=your_wallet_address    # Required: wallet address for data queries
 ```
+
+### Signer vs Owner Wallet
+
+The SDK distinguishes between two wallet concepts:
+
+- **Signer Wallet**: The wallet that signs transactions and orders (derived from `PRIVATE_KEY`)
+- **Owner Wallet**: The wallet whose data you want to query (positions, orders, balances, etc.)
+
+In most cases, these are the same wallet (set `OWNER_WALLET_ADDRESS` to the address derived from your `PRIVATE_KEY`). However, in Reya DEX, one address can trade on behalf of another wallet. The `OWNER_WALLET_ADDRESS` is used for all wallet data query methods (`get_positions()`, `get_open_orders()`, etc.), while order signatures always use the signer wallet address.
 ### Resource-Based API Structure
 
 #### REST API Structure

examples/rest_api/account_info.py

@@ -18,12 +18,12 @@ async def main():
     load_dotenv()
 
     async with ReyaTradingClient() as client:
-        if not client.wallet_address:
+        if not client.owner_wallet_address:
             print("Error: No wallet address found in environment variables.")
             print("Please set either WALLET_ADDRESS or PRIVATE_KEY in your .env file.")
             return
 
-        print(f"Using wallet address: {client.wallet_address}")
+        print(f"Using wallet address: {client.owner_wallet_address}")
 
         print("\n--- Getting accounts ---")
 

examples/rest_api/markets_example.py

@@ -32,7 +32,7 @@ async def main():
 
         if config:
             print(f"\n--- Getting trades for market {symbol} ---")
-            trades = await client.wallet.get_wallet_perp_executions(address=client.wallet_address or "")
+            trades = await client.wallet.get_wallet_perp_executions(address=client.owner_wallet_address or "")
             print(f"Market trades: {trades}")
 
             print(f"\n--- Getting trackers for market {symbol} ---")

examples/rest_api/order_entry.py

@@ -216,7 +216,7 @@ async def run_order_retrieval_test(client: ReyaTradingClient):
 
     # Get trades
     logger.info("Retrieving trades...")
-    trades = await client.wallet.get_wallet_perp_executions(address=client.wallet_address or "")
+    trades = await client.wallet.get_wallet_perp_executions(address=client.owner_wallet_address or "")
     logger.info(f"📊 Found {len(trades.data)} trades")
 
     # Get open orders
@@ -253,7 +253,7 @@ async def main():
         logger.info(f"   Account ID: {client.config.account_id}")
         logger.info(f"   Chain ID: {client.config.chain_id}")
         logger.info(f"   API URL: {client.config.api_url}")
-        logger.info(f"   Wallet: {client.wallet_address}")
+        logger.info(f"   Wallet: {client.owner_wallet_address}")
 
         await client.start()
 

examples/rest_api/wallet_example.py

@@ -33,13 +33,13 @@ async def main():
     # Create a client instance with configuration from environment variables
     async with ReyaTradingClient() as client:
         # Check if we have a wallet address (either directly or derived from private key)
-        if not client.wallet_address:
+        if not client.owner_wallet_address:
             print("Error: No wallet address found in environment variables.")
             print("Please set either WALLET_ADDRESS or PRIVATE_KEY in your .env file.")
             return
 
         # Show the wallet address we're using
-        print(f"Using wallet address: {client.wallet_address}")
+        print(f"Using wallet address: {client.owner_wallet_address}")
 
         # Get open orders for the wallet
         print("\n--- Getting open orders ---")

examples/websocket/wallet_monitoring.py

@@ -6,7 +6,7 @@
 - PRIVATE_KEY: Your Ethereum private key
 - ACCOUNT_ID: Your Reya account ID
 - CHAIN_ID: The chain ID (1729 for mainnet, 89346162 for testnet)
-- WALLET_ADDRESS: The wallet address to monitor
+- OWNER_WALLET_ADDRESS: The owner wallet address to monitor (required)
 """
 
 from typing import Any
@@ -38,10 +38,10 @@ def on_open(ws):
     """Handle WebSocket connection open event."""
     logger.info("Connection established, subscribing to wallet data")
 
-    # Get wallet address from environment
-    wallet_address = os.environ.get("WALLET_ADDRESS")
+    # Get owner wallet address from environment
+    wallet_address = os.environ.get("OWNER_WALLET_ADDRESS")
     if not wallet_address:
-        logger.error("WALLET_ADDRESS environment variable not set")
+        logger.error("OWNER_WALLET_ADDRESS environment variable is required")
         return
 
     logger.info(f"Monitoring wallet: {wallet_address}")

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reya-python-sdk"
-version = "2.0.6.0"
+version = "2.0.6.1"
 description = "SDK for interacting with Reya Labs APIs"
 authors = [
     {name = "Reya Labs"}

sdk/reya_rest_api/auth/signatures.py

@@ -32,13 +32,13 @@ def __init__(self, config: TradingConfig):
         if not self._private_key:
             raise ValueError("Private key is required for signing")
 
-        # Calculate public address from private key
-        self._public_address: str = str(Account.from_key(self._private_key).address)
+        # Calculate signer wallet address from private key
+        self._signer_wallet_address: str = str(Account.from_key(self._private_key).address)
 
     @property
-    def public_address(self) -> str:
-        """Get the public address derived from the private key."""
-        return self._public_address
+    def signer_wallet_address(self) -> str:
+        """Get the signer wallet address derived from the private key."""
+        return self._signer_wallet_address
 
     def scale(self, decimals: int):
         """Returns a function that scales a number (str, int, float, or Decimal) to an integer."""
@@ -160,7 +160,7 @@ def sign_raw_order(
                 "counterpartyAccountIds": counterparty_account_ids,
                 "orderType": order_type,
                 "inputs": inputs,
-                "signer": self._public_address,
+                "signer": self._signer_wallet_address,
                 "nonce": nonce,
             },
         }

sdk/reya_rest_api/client.py

@@ -67,7 +67,6 @@ def __init__(
         api_url: Optional[str] = None,
         chain_id: Optional[int] = None,
         account_id: Optional[int] = None,
-        wallet_address: Optional[str] = None,
     ):
         """
         Initialize the Reya Trading client.
@@ -103,8 +102,6 @@ def __init__(
             self._config.chain_id = chain_id
         if account_id:
             self._config.account_id = account_id
-        if wallet_address:
-            self._config.wallet_address = wallet_address
 
         # Create signature generator
         self._signature_generator = SignatureGenerator(self._config)
@@ -175,14 +172,19 @@ def config(self) -> TradingConfig:
         return self._config
 
     @property
-    def wallet_address(self) -> Optional[str]:
-        """Get the wallet address from config or signature generator."""
-        # First check if wallet address is directly provided in config
-        if self._config.wallet_address:
-            return self._config.wallet_address
+    def signer_wallet_address(self) -> str:
+        """Get the signer wallet address (derived from private key)."""
+        return self._signature_generator.signer_wallet_address
 
-        # Otherwise derive it from private key if available
-        return self._signature_generator.public_address if self._signature_generator else None
+    @property
+    def owner_wallet_address(self) -> str:
+        """
+        Get the owner wallet address for querying wallet data.
+
+        Wallet that owns ACCOUNT_ID, the signer_wallet will either be the same as owner_wallet_address, or a wallet
+        that was given permissions to trade on behalf ot he owner_wallet_address
+        """
+        return self._config.owner_wallet_address
 
     async def create_limit_order(self, params: LimitOrderParameters) -> CreateOrderResponse:
         """
@@ -254,8 +256,6 @@ async def create_limit_order(self, params: LimitOrderParameters) -> CreateOrderR
         # Build the order request
         if self.config.account_id is None:
             raise ValueError("Account ID is required for order creation")
-        if self.config.wallet_address is None:
-            raise ValueError("Wallet address is required for order creation")
 
         order_request = CreateOrderRequest(
             accountId=self.config.account_id,
@@ -270,7 +270,7 @@ async def create_limit_order(self, params: LimitOrderParameters) -> CreateOrderR
             reduceOnly=params.reduce_only,
             signature=signature,
             nonce=str(nonce),
-            signerWallet=self.config.wallet_address,
+            signerWallet=self.signer_wallet_address,
         )
 
         response = await self.orders.create_order(create_order_request=order_request)
@@ -329,8 +329,6 @@ async def create_trigger_order(self, params: TriggerOrderParameters) -> CreateOr
 
         if self.config.account_id is None:
             raise ValueError("Account ID is required for order creation")
-        if self.config.wallet_address is None:
-            raise ValueError("Wallet address is required for order creation")
 
         order_request = CreateOrderRequest(
             accountId=self.config.account_id,
@@ -343,7 +341,7 @@ async def create_trigger_order(self, params: TriggerOrderParameters) -> CreateOr
             expiresAfter=None,
             signature=signature,
             nonce=str(nonce),
-            signerWallet=self.config.wallet_address,
+            signerWallet=self.signer_wallet_address,
         )
 
         response = await self.orders.create_order(create_order_request=order_request)
@@ -379,111 +377,111 @@ async def get_positions(self, wallet_address: Optional[str] = None) -> list[Posi
         Get positions for a wallet address asynchronously.
 
         Args:
-            wallet_address: Optional wallet address (defaults to current wallet)
+            wallet_address: Optional wallet address (defaults to owner_wallet_address)
 
         Returns:
             Positions data
 
         Raises:
             ValueError: If no wallet address is available or API returns an error
         """
-        wallet = wallet_address or self.wallet_address
+        wallet = wallet_address or self.owner_wallet_address
         if not wallet:
             raise ValueError("No wallet address available. Private key must be provided.")
 
         return await self.wallet.get_wallet_positions(address=wallet)
 
     async def get_open_orders(self) -> list[Order]:
         """
-        Get open orders for the authenticated wallet asynchronously.
+        Get open orders for the owner wallet asynchronously.
 
         Returns:
             List of open orders
 
         Raises:
             ValueError: If no wallet address is available or API returns an error
         """
-        wallet = self.wallet_address
+        wallet = self.owner_wallet_address
         if not wallet:
             raise ValueError("No wallet address available. Private key must be provided.")
 
         return await self.wallet.get_wallet_open_orders(address=wallet)
 
     async def get_configuration(self) -> WalletConfiguration:
         """
-        Get account configuration asynchronously.
+        Get account configuration for the owner wallet asynchronously.
 
         Returns:
             Account configuration information
 
         Raises:
             ValueError: If no wallet address is available or API returns an error
         """
-        wallet = self.wallet_address
+        wallet = self.owner_wallet_address
         if not wallet:
             raise ValueError("No wallet address available. Private key must be provided.")
 
         return await self.wallet.get_wallet_configuration(address=wallet)
 
     async def get_perp_executions(self) -> PerpExecutionList:
         """
-        Get perp executions for the authenticated wallet asynchronously.
+        Get perp executions for the owner wallet asynchronously.
 
         Returns:
             Dictionary containing trades data and metadata
 
         Raises:
             ValueError: If no wallet address is available or API returns an error
         """
-        wallet = self.wallet_address
+        wallet = self.owner_wallet_address
         if not wallet:
             raise ValueError("No wallet address available. Private key must be provided.")
 
         return await self.wallet.get_wallet_perp_executions(address=wallet)
 
     async def get_accounts(self) -> list[Account]:
         """
-        Get accounts for the authenticated wallet asynchronously.
+        Get accounts for the owner wallet asynchronously.
 
         Returns:
             Account information
 
         Raises:
             ValueError: If no wallet address is available or API returns an error
         """
-        wallet = self.wallet_address
+        wallet = self.owner_wallet_address
         if not wallet:
             raise ValueError("No wallet address available. Private key must be provided.")
 
         return await self.wallet.get_wallet_accounts(address=wallet)
 
     async def get_account_balances(self) -> list[AccountBalance]:
         """
-        Get account balances for the authenticated wallet asynchronously.
+        Get account balances for the owner wallet asynchronously.
 
         Returns:
             Account balances
 
         Raises:
             ValueError: If no wallet address is available or API returns an error
         """
-        wallet = self.wallet_address
+        wallet = self.owner_wallet_address
         if not wallet:
             raise ValueError("No wallet address available. Private key must be provided.")
 
         return await self.wallet.get_wallet_account_balances(address=wallet)
 
     async def get_spot_executions(self) -> SpotExecutionList:
         """
-        Get spot executions (i.e. auto exchanges) for the authenticated wallet asynchronously.
+        Get spot executions (i.e. auto exchanges) for the owner wallet asynchronously.
 
         Returns:
             Spot executions
 
         Raises:
             ValueError: If no wallet address is available or API returns an error
         """
-        wallet = self.wallet_address
+        wallet = self.owner_wallet_address
         if not wallet:
             raise ValueError("No wallet address available. Private key must be provided.")