# Authorization flow

#### JWT Authentication

The `auth()` method allows you to authenticate a wallet and receive a JWT token. This is useful for backend authentication and verifying wallet ownership.

**How it works:**

1. Opens a UI popup asking the user to sign a message
2. Generates a random seed and creates a cryptographic nonce
3. Signs intents (or empty array) with the nonce
4. Sends the signed commitment to the API
5. Returns a JWT token string

**Basic Usage:**

```typescript
// Get JWT token for authentication
const wallet = wibe3.priorityWallet; // or any connected wallet
if (wallet) {
  const jwt = await wallet.auth();
  console.log("JWT token:", jwt);

  // Use JWT for backend authentication
  // Example: send to your backend API
  await fetch("https://your-api.com/authenticate", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${jwt}`,
      "Content-Type": "application/json",
    },
  });
}
```

**Auth with Intents (Optional):**

You can optionally pass intents to be signed during authentication:

```typescript
// Auth with intents (optional)
const intents = [{
   intent: "transfer",
   recipient: "petya.near",
   token: OmniToken.USDC,
   amount: 10,
}];

const jwt = await wibe3.priorityWallet.auth(intents);
console.log("JWT with signed intents:", jwt);
```

**Validate JWT Token:**

You can validate a JWT token using the API:

```typescript
import { api } from "@hot-labs/kit";

// Validate JWT token
const isValid = await api.validateAuth(jwt);
console.log("Token is valid:", isValid);
```

**Complete Example:**

```tsx
import { observer } from "mobx-react-lite";
import { HotConnector } from "@hot-labs/kit";

const wibe3 = new HotConnector({ ... });

const App = observer(() => {
  const handleAuthenticate = async () => {
    const wallet = wibe3.priorityWallet;
    if (!wallet) return alert("Please connect a wallet first");

    try {
      // Get JWT token
      const jwt = await wallet.auth();

      // Store JWT (e.g., in localStorage or send to backend)
      localStorage.setItem("authToken", jwt);

      // Use JWT for authenticated API calls
      const response = await fetch("https://your-api.com/user/profile", {
        headers: { Authorization: `Bearer ${jwt}` },
      });

      const userData = await response.json();
      console.log("User data:", userData);
      alert("Authentication successful!");
    } catch (error) {
      console.error("Authentication failed:", error);
      alert("Authentication failed");
    }
  };

  return (
    <div>
      <button onClick={handleAuthenticate}>Authenticate & Get JWT</button>
    </div>
  );
});
```

**Important Notes:**

* The `auth()` method opens a UI popup that requires user interaction to sign the message
* The JWT token is generated server-side and returned after successful signature verification
* The token can be used for backend authentication to verify wallet ownership
* The authentication process is safe - it only signs a message, not a transaction
* You can optionally pass intents to be signed during authentication


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hotdao.ai/hot-kit/authorization-flow.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.