prividium 0.3.1 → 0.5.0

package/README.md

@@ -6,7 +6,8 @@ RPC and manages basic configuration.
 
 ## Features
 
-- 🔐 **Popup-based OAuth Authentication** - Secure authentication flow using popup windows
+- 🔐 **Popup-based OAuth Authentication** - Secure authentication flow using popup windows (browser)
+- 🔑 **SIWE Backend Authentication** - Programmatic Sign-In with Ethereum for server-side use (`prividium/siwe`)
 - 🔑 **JWT Token Management** - Automatic token storage, validation, and expiration handling
 - 🌐 **Viem Integration** - Drop-in transport for viem clients with automatic auth headers
 - 🛠️ **CLI Proxy** - Local authenticated JSON-RPC proxy and simple config management
@@ -359,6 +360,72 @@ interface PrividiumClientConfig {
 
 **Returns:** `PublicClient` - Viem client instance.
 
+## SIWE Backend Authentication
+
+For server-side or backend use cases, the SDK provides a separate entry point with programmatic SIWE (Sign-In with
+Ethereum) authentication. Instead of a browser popup, you provide a viem account and the SDK handles the entire flow
+automatically.
+
+### Quick Start (SIWE)
+
+```typescript
+import { createPrividiumSiweChain } from 'prividium/siwe';
+import { privateKeyToAccount } from 'viem/accounts';
+
+const account = privateKeyToAccount('0xYOUR_PRIVATE_KEY');
+
+const prividium = createPrividiumSiweChain({
+  account,
+  chain: { id: 7777, name: 'Prividium™ Chain' },
+  prividiumApiBaseUrl: 'https://permissions.prividium.io',
+  domain: 'my-backend.example.com',
+  onReauthenticate: () => console.log('Session automatically refreshed'),
+  onReauthenticateError: (err) => console.error('Re-auth failed:', err)
+});
+
+// Authenticate
+await prividium.authorize();
+
+// Make authenticated API calls
+const user = await prividium.fetchUser();
+
+// Transport automatically reauthenticates on session expiry
+const balance = await client.getBalance({ address: prividium.address });
+```
+
+### `createPrividiumSiweChain(config)`
+
+Creates an SDK instance with programmatic SIWE authentication.
+
+**Parameters:**
+
+```typescript
+interface PrividiumSiweConfig {
+  chain: Chain; // Viem chain configuration (without rpcUrls)
+  prividiumApiBaseUrl: string; // Permissions API service base URL
+  account: LocalAccount; // Viem account for signing (e.g. from privateKeyToAccount)
+  domain: string; // Domain for SIWE message
+  storage?: Storage; // Custom storage (defaults to MemoryStorage)
+  autoReauthenticate?: boolean; // Auto-reauth on session expiry (default: true)
+  onAuthExpiry?: () => void; // Called when auth expires and reauth is disabled/failed
+  onReauthenticate?: () => void; // Called after successful automatic reauthentication
+  onReauthenticateError?: (error: Error) => void; // Called when automatic reauthentication fails
+}
+```
+
+**Returns:** `PrividiumSiweChain` - with all the same methods as `PrividiumChain` (except `addNetworkToWallet` which is
+browser-only), plus `address` (the wallet address derived from the account).
+
+### Auto-Reauthentication
+
+When `autoReauthenticate` is `true` (default), the SDK automatically handles expired sessions:
+
+1. Before each API call, checks if the session is still valid
+2. On 401/403 responses, reauthenticates and retries the call once
+3. Concurrent reauth attempts are deduplicated (only one SIWE flow runs at a time)
+
+Disable with `autoReauthenticate: false` to handle expiry manually via `onAuthExpiry`.
+
 ## Advanced Usage
 
 ### Custom Storage

package/dist/sdk/chain-core.d.ts

@@ -0,0 +1,20 @@
+import type { Chain } from 'viem';
+import { z, type ZodType } from 'zod';
+import { type AuthorizeTransactionParams, type AuthorizeTransactionResponse, type UserProfile } from './types.js';
+export declare function rpcUrl(apiUrl: string): string;
+export declare function walletRpcUrl(apiUrl: string, token: string): string;
+export declare function buildChainObject(config: {
+    chain: Omit<Chain, 'rpcUrls'>;
+    prividiumApiBaseUrl: string;
+}): Chain;
+export type ApiCaller = <Schema extends ZodType>(schema: Schema, url: string, method: 'GET' | 'POST', body?: string) => Promise<z.infer<Schema>>;
+export declare function createApiMethods(deps: {
+    prividiumApiCall: ApiCaller;
+    prividiumApiBaseUrl: string;
+}): {
+    fetchUser(): Promise<UserProfile>;
+    getWalletToken(): Promise<string>;
+    getWalletRpcUrl(): Promise<string>;
+    invalidateWalletToken(): Promise<string>;
+    authorizeTransaction(params: AuthorizeTransactionParams): Promise<AuthorizeTransactionResponse>;
+};

package/dist/sdk/chain-core.js

@@ -0,0 +1,50 @@
+import { mainnet } from 'viem/chains';
+import { z } from 'zod';
+import { authorizeTransactionResponseSchema, profileSchema } from './types.js';
+export function rpcUrl(apiUrl) {
+    return new URL('/rpc', apiUrl).toString();
+}
+export function walletRpcUrl(apiUrl, token) {
+    return new URL(`/rpc/wallet/${token}`, apiUrl).toString();
+}
+export function buildChainObject(config) {
+    return {
+        ...mainnet,
+        ...config.chain,
+        id: config.chain.id,
+        contracts: {
+            ...config.chain.contracts,
+            multicall3: undefined // Prividium™ doesn't support multicall yet
+        },
+        rpcUrls: { default: { http: [rpcUrl(config.prividiumApiBaseUrl)] } },
+        blockExplorers: config.chain.blockExplorers
+    };
+}
+export function createApiMethods(deps) {
+    const { prividiumApiCall, prividiumApiBaseUrl } = deps;
+    return {
+        async fetchUser() {
+            return await prividiumApiCall(profileSchema, `${prividiumApiBaseUrl}/api/profiles/me`, 'GET');
+        },
+        async getWalletToken() {
+            const { token } = await prividiumApiCall(z.object({ token: z.string() }), `${prividiumApiBaseUrl}/api/wallet/personal-rpc-token`, 'GET');
+            return token;
+        },
+        async getWalletRpcUrl() {
+            const walletToken = await this.getWalletToken();
+            return walletRpcUrl(prividiumApiBaseUrl, walletToken);
+        },
+        async invalidateWalletToken() {
+            const { newWalletToken } = await prividiumApiCall(z.object({ newWalletToken: z.string(), message: z.string() }), `${prividiumApiBaseUrl}/api/wallet/invalidate`, 'POST');
+            return newWalletToken;
+        },
+        async authorizeTransaction(params) {
+            return prividiumApiCall(authorizeTransactionResponseSchema, `${prividiumApiBaseUrl}/api/wallet/transaction-authorization`, 'POST', JSON.stringify({
+                ...params,
+                // Always pass calldata and value, even if undefined
+                calldata: params?.calldata ?? '0x',
+                value: params.value?.toString() ?? '0'
+            }));
+        }
+    };
+}

package/dist/sdk/error-utils.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { UNAUTHORIZED_ERROR_CODE, FORBIDDEN_ERROR_CODE } from './rpc-error-codes.js';
+import { UNAUTHORIZED_ERROR_CODE } from './rpc-error-codes.js';
 const jsonRpcErrorSchema = z.object({
     error: z.object({
         code: z.number(),
@@ -15,7 +15,7 @@ export async function hasPrividiumUnauthorizedError(response) {
     const parsed = jsonRpcErrorSchema.safeParse(await clonedResponse.json());
     // { success: false, error: {...} } | { success: true, data: {...} }
     if (parsed.success) {
-        return [UNAUTHORIZED_ERROR_CODE, FORBIDDEN_ERROR_CODE].includes(parsed.data.error.code);
+        return parsed.data.error.code === UNAUTHORIZED_ERROR_CODE;
     }
     return false;
 }

package/dist/sdk/memory-storage.d.ts

@@ -0,0 +1,7 @@
+import type { Storage } from './types.js';
+export declare class MemoryStorage implements Storage {
+    private store;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}

package/dist/sdk/memory-storage.js

@@ -0,0 +1,12 @@
+export class MemoryStorage {
+    store = new Map();
+    getItem(key) {
+        return this.store.get(key) ?? null;
+    }
+    setItem(key, value) {
+        this.store.set(key, value);
+    }
+    removeItem(key) {
+        this.store.delete(key);
+    }
+}

package/dist/sdk/prividium-chain.d.ts

@@ -1,4 +1,4 @@
-import { type PrividiumChain, type PrividiumConfig } from './types.js';
+import type { PrividiumChain, PrividiumConfig } from './types.js';
 declare global {
     interface Window {
         ethereum?: {

package/dist/sdk/prividium-chain.js

@@ -1,17 +1,9 @@
 import { http } from 'viem';
-import { mainnet } from 'viem/chains';
-import { authorizeTransactionResponseSchema, profileSchema } from './types.js';
 import { LocalStorage, TokenManager } from './storage.js';
 import { PopupAuth } from './popup-auth.js';
 import { hasPrividiumUnauthorizedError } from './error-utils.js';
-import { PrividiumSessionError } from './errors';
-import { z } from 'zod';
-function rpcUrl(apiUrl) {
-    return new URL('/rpc', apiUrl).toString();
-}
-function walletRpcUrl(apiUrl, token) {
-    return new URL(`/rpc/wallet/${token}`, apiUrl).toString();
-}
+import { PrividiumSessionError } from './errors.js';
+import { buildChainObject, createApiMethods, rpcUrl } from './chain-core.js';
 export function createPrividiumChain(config) {
     if (config.permissionsApiBaseUrl !== undefined) {
         throw new Error('"permissionsApiBaseUrl" was deprecated. Please use "prividiumApiBaseUrl" instead.');
@@ -46,7 +38,7 @@ export function createPrividiumChain(config) {
             },
             ...(body && { body })
         });
-        if (response.status === 403 || response.status === 401) {
+        if (response.status === 401) {
             tokenManager.clearToken();
             config.onAuthExpiry?.();
             throw new PrividiumSessionError();
@@ -84,18 +76,9 @@ export function createPrividiumChain(config) {
             }
         }
     });
+    const apiMethods = createApiMethods({ prividiumApiCall, prividiumApiBaseUrl: config.prividiumApiBaseUrl });
     return {
-        chain: {
-            ...mainnet,
-            ...config.chain,
-            id: config.chain.id,
-            contracts: {
-                ...config.chain.contracts,
-                multicall3: undefined // Prividium™ doesn't support multicall yet
-            },
-            rpcUrls: { default: { http: [rpcUrl(config.prividiumApiBaseUrl)] } },
-            blockExplorers: config.chain.blockExplorers
-        },
+        chain: buildChainObject(config),
         transport,
         async authorize(options) {
             return popupAuth.authorize(options);
@@ -107,29 +90,11 @@ export function createPrividiumChain(config) {
             return popupAuth.isAuthorized();
         },
         getAuthHeaders,
-        async fetchUser() {
-            return await prividiumApiCall(profileSchema, `${config.prividiumApiBaseUrl}/api/profiles/me`, 'GET');
-        },
-        async getWalletToken() {
-            const { token } = await prividiumApiCall(z.object({ token: z.string() }), `${config.prividiumApiBaseUrl}/api/wallet/personal-rpc-token`, 'GET');
-            return token;
-        },
-        async getWalletRpcUrl() {
-            const walletToken = await this.getWalletToken();
-            return walletRpcUrl(config.prividiumApiBaseUrl, walletToken);
-        },
-        async invalidateWalletToken() {
-            const { newWalletToken } = await prividiumApiCall(z.object({ newWalletToken: z.string(), message: z.string() }), `${config.prividiumApiBaseUrl}/api/wallet/invalidate`, 'POST');
-            return newWalletToken;
-        },
-        async authorizeTransaction(params) {
-            return prividiumApiCall(authorizeTransactionResponseSchema, `${config.prividiumApiBaseUrl}/api/wallet/transaction-authorization`, 'POST', JSON.stringify({
-                ...params,
-                // Always pass calldata and value, even if undefined
-                calldata: params?.calldata ?? '0x',
-                value: params.value?.toString() ?? '0'
-            }));
-        },
+        fetchUser: apiMethods.fetchUser,
+        getWalletToken: apiMethods.getWalletToken,
+        getWalletRpcUrl: apiMethods.getWalletRpcUrl,
+        invalidateWalletToken: apiMethods.invalidateWalletToken,
+        authorizeTransaction: apiMethods.authorizeTransaction,
         async addNetworkToWallet(params) {
             if (typeof window === 'undefined' || !window.ethereum) {
                 throw new Error('Wallet not detected. Please install a wallet extension to add network.');

package/dist/sdk/siwe-auth.d.ts

@@ -0,0 +1,17 @@
+import type { Address, LocalAccount } from 'viem';
+import type { TokenManager } from './storage.js';
+import type { TokenData } from './types.js';
+export interface SiweAuthConfig {
+    account: LocalAccount;
+    prividiumApiBaseUrl: string;
+    domain: string;
+    tokenManager: TokenManager;
+}
+export declare class SiweAuth {
+    private config;
+    constructor(config: SiweAuthConfig);
+    get address(): Address;
+    authorize(): Promise<TokenData>;
+    unauthorize(): void;
+    isAuthorized(): boolean;
+}

package/dist/sdk/siwe-auth.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+const siweMessageResponseSchema = z.object({
+    msg: z.string()
+});
+const siweLoginResponseSchema = z.object({
+    token: z.string(),
+    expiresAt: z.string()
+});
+const mfaResponseSchema = z.object({
+    requiresMfa: z.literal(true)
+});
+export class SiweAuth {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get address() {
+        return this.config.account.address;
+    }
+    async authorize() {
+        // Step 1: Request SIWE message
+        const siweMessageUrl = new URL('/api/siwe-messages', this.config.prividiumApiBaseUrl).toString();
+        const siweResponse = await fetch(siweMessageUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                address: this.config.account.address,
+                domain: this.config.domain
+            })
+        });
+        if (!siweResponse.ok) {
+            throw new Error(`Failed to get SIWE message: ${siweResponse.status} ${siweResponse.statusText}`);
+        }
+        const siweData = siweMessageResponseSchema.parse(await siweResponse.json());
+        // Step 2: Sign the message
+        const signature = await this.config.account.signMessage({ message: siweData.msg });
+        // Step 3: Login
+        const loginUrl = new URL('/auth/login/crypto-native', this.config.prividiumApiBaseUrl).toString();
+        const loginResponse = await fetch(loginUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ message: siweData.msg, signature })
+        });
+        if (!loginResponse.ok) {
+            throw new Error(`SIWE login failed: ${loginResponse.status} ${loginResponse.statusText}`);
+        }
+        const loginJson = await loginResponse.json();
+        // Check for MFA requirement (admin users with passkeys)
+        const mfaParsed = mfaResponseSchema.safeParse(loginJson);
+        if (mfaParsed.success) {
+            throw new Error('SIWE login requires MFA which is not supported in programmatic auth');
+        }
+        const loginData = siweLoginResponseSchema.parse(loginJson);
+        // Step 4: Store token directly (login response includes expiresAt)
+        const tokenData = {
+            rawToken: loginData.token,
+            expiresAt: new Date(loginData.expiresAt)
+        };
+        this.config.tokenManager.setTokenDirect(tokenData);
+        return tokenData;
+    }
+    unauthorize() {
+        this.config.tokenManager.clearToken();
+    }
+    isAuthorized() {
+        return this.config.tokenManager.isAuthorized();
+    }
+}

package/dist/sdk/siwe-chain.d.ts

@@ -0,0 +1,28 @@
+import { type Address, type Chain, type LocalAccount, type Transport } from 'viem';
+import type { AuthorizeTransactionParams, AuthorizeTransactionResponse, Storage, TokenData, UserProfile } from './types.js';
+export interface PrividiumSiweConfig {
+    chain: Omit<Chain, 'rpcUrls'>;
+    prividiumApiBaseUrl: string;
+    account: LocalAccount;
+    domain: string;
+    storage?: Storage;
+    autoReauthenticate?: boolean;
+    onAuthExpiry?: () => void;
+    onReauthenticate?: () => void;
+    onReauthenticateError?: (error: Error) => void;
+}
+export interface PrividiumSiweChain {
+    chain: Chain;
+    transport: Transport;
+    address: Address;
+    authorize(): Promise<TokenData>;
+    unauthorize(): void;
+    isAuthorized(): boolean;
+    getAuthHeaders(): Record<string, string> | null;
+    fetchUser(): Promise<UserProfile>;
+    getWalletToken(): Promise<string>;
+    getWalletRpcUrl(): Promise<string>;
+    invalidateWalletToken(): Promise<string>;
+    authorizeTransaction(params: AuthorizeTransactionParams): Promise<AuthorizeTransactionResponse>;
+}
+export declare function createPrividiumSiweChain(config: PrividiumSiweConfig): PrividiumSiweChain;

package/dist/sdk/siwe-chain.js

@@ -0,0 +1,166 @@
+import { http } from 'viem';
+import { TokenManager } from './storage.js';
+import { MemoryStorage } from './memory-storage.js';
+import { SiweAuth } from './siwe-auth.js';
+import { hasPrividiumUnauthorizedError } from './error-utils.js';
+import { PrividiumSessionError } from './errors.js';
+import { buildChainObject, createApiMethods, rpcUrl } from './chain-core.js';
+export function createPrividiumSiweChain(config) {
+    const autoReauth = config.autoReauthenticate ?? true;
+    const storage = config.storage ?? new MemoryStorage();
+    const tokenManager = new TokenManager(storage, config.chain.id, config.prividiumApiBaseUrl, config.onAuthExpiry);
+    const siweAuth = new SiweAuth({
+        account: config.account,
+        prividiumApiBaseUrl: config.prividiumApiBaseUrl,
+        domain: config.domain,
+        tokenManager
+    });
+    // Deduplication: only one reauthentication flow at a time
+    let reauthPromise = null;
+    async function reauthenticate() {
+        if (reauthPromise) {
+            return reauthPromise;
+        }
+        reauthPromise = (async () => {
+            try {
+                const tokenData = await siweAuth.authorize();
+                config.onReauthenticate?.();
+                return tokenData;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                config.onReauthenticateError?.(err);
+                throw err;
+            }
+            finally {
+                reauthPromise = null;
+            }
+        })();
+        return reauthPromise;
+    }
+    async function ensureAuthorized() {
+        if (!tokenManager.isAuthorized() && autoReauth) {
+            await reauthenticate();
+        }
+        if (!tokenManager.isAuthorized()) {
+            throw new PrividiumSessionError();
+        }
+    }
+    const getAuthHeaders = () => {
+        const tokenData = tokenManager.getToken();
+        if (!tokenData) {
+            return null;
+        }
+        return {
+            Authorization: `Bearer ${tokenData.rawToken}`
+        };
+    };
+    async function prividiumApiCall(schema, url, method, body) {
+        await ensureAuthorized();
+        const headers = getAuthHeaders();
+        if (!headers) {
+            throw new PrividiumSessionError();
+        }
+        const response = await fetch(url, {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers
+            },
+            ...(body && { body })
+        });
+        if (response.status === 401) {
+            tokenManager.clearToken();
+            // Attempt reauthentication and retry once
+            if (autoReauth) {
+                try {
+                    await reauthenticate();
+                    const retryHeaders = getAuthHeaders();
+                    if (!retryHeaders)
+                        throw new PrividiumSessionError();
+                    const retryResponse = await fetch(url, {
+                        method,
+                        headers: { 'Content-Type': 'application/json', ...retryHeaders },
+                        ...(body && { body })
+                    });
+                    if (!retryResponse.ok) {
+                        config.onAuthExpiry?.();
+                        throw new PrividiumSessionError();
+                    }
+                    const parsed = schema.safeParse(await retryResponse.json());
+                    if (!parsed.success) {
+                        throw new Error(`Unexpected api response calling ${url}`);
+                    }
+                    return parsed.data;
+                }
+                catch {
+                    config.onAuthExpiry?.();
+                    throw new PrividiumSessionError();
+                }
+            }
+            config.onAuthExpiry?.();
+            throw new PrividiumSessionError();
+        }
+        if (!response.ok) {
+            throw new Error(`Error calling ${url}: ${response.status} ${response.statusText}`);
+        }
+        const parsed = schema.safeParse(await response.json());
+        if (!parsed.success) {
+            throw new Error(`Unexpected api response calling ${url}`);
+        }
+        return parsed.data;
+    }
+    // Create transport with auth integration using viem callbacks
+    const transport = http(rpcUrl(config.prividiumApiBaseUrl), {
+        batch: false,
+        fetchOptions: {
+            headers: getAuthHeaders() || {}
+        },
+        onFetchRequest(_request, init) {
+            if (!tokenManager.isAuthorized()) {
+                throw new PrividiumSessionError();
+            }
+            init.headers = {
+                ...init.headers,
+                ...getAuthHeaders()
+            };
+        },
+        onFetchResponse: async (response) => {
+            if (await hasPrividiumUnauthorizedError(response)) {
+                tokenManager.clearToken();
+                if (autoReauth) {
+                    try {
+                        await reauthenticate();
+                    }
+                    catch {
+                        config.onAuthExpiry?.();
+                    }
+                }
+                else {
+                    config.onAuthExpiry?.();
+                }
+            }
+        }
+    });
+    const apiMethods = createApiMethods({ prividiumApiCall, prividiumApiBaseUrl: config.prividiumApiBaseUrl });
+    return {
+        chain: buildChainObject(config),
+        transport,
+        address: config.account.address,
+        async authorize() {
+            return siweAuth.authorize();
+        },
+        unauthorize() {
+            siweAuth.unauthorize();
+        },
+        isAuthorized() {
+            return siweAuth.isAuthorized();
+        },
+        getAuthHeaders,
+        fetchUser: apiMethods.fetchUser,
+        getWalletToken: apiMethods.getWalletToken,
+        getWalletRpcUrl: apiMethods.getWalletRpcUrl,
+        invalidateWalletToken: apiMethods.invalidateWalletToken,
+        authorizeTransaction: apiMethods.authorizeTransaction
+    };
+}

package/dist/sdk/siwe.d.ts

@@ -0,0 +1,11 @@
+export { createPrividiumSiweChain } from './siwe-chain.js';
+export type { PrividiumSiweConfig, PrividiumSiweChain } from './siwe-chain.js';
+export { SiweAuth } from './siwe-auth.js';
+export type { SiweAuthConfig } from './siwe-auth.js';
+export { MemoryStorage } from './memory-storage.js';
+export { TokenManager } from './storage.js';
+export type { Storage, TokenData } from './types.js';
+export { createPrividiumClient } from './create-prividium-client.js';
+export type { UserProfile, UserRole, AuthorizeTransactionParams, AuthorizeTransactionResponse } from './types.js';
+export { AUTH_ERRORS } from './types.js';
+export { UNAUTHORIZED_ERROR_CODE, FORBIDDEN_ERROR_CODE } from './rpc-error-codes.js';

package/dist/sdk/siwe.js

@@ -0,0 +1,11 @@
+// Core factory + types
+export { createPrividiumSiweChain } from './siwe-chain.js';
+// Auth strategy
+export { SiweAuth } from './siwe-auth.js';
+// Storage (MemoryStorage is the default for SIWE, but expose both + interface)
+export { MemoryStorage } from './memory-storage.js';
+export { TokenManager } from './storage.js';
+// Viem client (reusable with SIWE chain)
+export { createPrividiumClient } from './create-prividium-client.js';
+export { AUTH_ERRORS } from './types.js';
+export { UNAUTHORIZED_ERROR_CODE, FORBIDDEN_ERROR_CODE } from './rpc-error-codes.js';

package/dist/sdk/storage.d.ts

@@ -16,6 +16,11 @@ export declare class TokenManager {
     getToken(): TokenData | null;
     private getTokenExpiration;
     setToken(rawToken: string): Promise<TokenData>;
+    /**
+     * Stores token data directly without fetching expiration from the API.
+     * Used by SIWE auth where the login response already includes expiresAt.
+     */
+    setTokenDirect(tokenData: TokenData): void;
     clearToken(): void;
     isAuthorized(): boolean;
     setState(state: string): void;

package/dist/sdk/storage.js

@@ -106,6 +106,14 @@ export class TokenManager {
             throw error;
         }
     }
+    /**
+     * Stores token data directly without fetching expiration from the API.
+     * Used by SIWE auth where the login response already includes expiresAt.
+     */
+    setTokenDirect(tokenData) {
+        this.storage.setItem(this.tokenKey, JSON.stringify(tokenData));
+        this.tokenCache = tokenData;
+    }
     clearToken() {
         this.tokenCache = null;
         this.storage.removeItem(this.tokenKey);

package/dist/tsconfig.sdk.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/create-prividium-client.ts","../src/error-utils.ts","../src/errors.ts","../src/index.ts","../src/popup-auth.ts","../src/prividium-chain.ts","../src/rpc-error-codes.ts","../src/storage.ts","../src/test-utils.ts","../src/token-utils.ts","../src/types.ts"],"version":"5.8.3"}
+{"root":["../src/chain-core.ts","../src/create-prividium-client.ts","../src/error-utils.ts","../src/errors.ts","../src/index.ts","../src/memory-storage.ts","../src/popup-auth.ts","../src/prividium-chain.ts","../src/rpc-error-codes.ts","../src/siwe-auth.ts","../src/siwe-chain.ts","../src/siwe.ts","../src/storage.ts","../src/test-utils.ts","../src/token-utils.ts","../src/types.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prividium",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "bin": {
     "prividium": "bin/cli.js"
   },
@@ -8,6 +8,10 @@
     ".": {
       "import": "./dist/sdk/index.js",
       "types": "./dist/sdk/index.d.ts"
+    },
+    "./siwe": {
+      "import": "./dist/sdk/siwe.js",
+      "types": "./dist/sdk/siwe.d.ts"
     }
   },
   "license": "MIT OR Apache-2.0",