prividium 1.3.1 → 1.4.0

package/README.md

@@ -1,8 +1,10 @@
 # Prividium™ SDK & CLI
 
-A TypeScript SDK and CLI for integrating with the Prividium™ authorization system. The SDK provides popup OAuth, token
-management, and a viem transport for secure RPC; the CLI runs a local authenticated JSON-RPC proxy to your Prividium™
-RPC and manages basic configuration.
+A TypeScript SDK and CLI for integrating with the Prividium™ authorization system. The SDK handles **authentication** —
+signing in with OIDC or SIWE and attaching your identity to each request — while Prividium™ enforces **authorization**
+server-side from your assigned roles, controlling which contract functions, events, and data you can access; the SDK
+does not grant permissions. It provides popup OAuth, token management, and a viem transport for secure RPC; the CLI runs
+a local authenticated JSON-RPC proxy to your Prividium™ RPC and manages basic configuration.
 
 ## Features
 

package/dist/cli/commands/doctor/probes/authentication/authentication.js

@@ -4,12 +4,10 @@ import { fetchAuthenticatedJson } from '../../clients/http.js';
 import { DEFAULT_DOCTOR_CALLBACK_PORT } from '../../constants.js';
 import { profileSchema } from '../../profile.js';
 export async function runBrowserAuthProbe(context) {
-    const token = await authenticateInBrowser(context.targets.userPanelBaseUrl, DEFAULT_DOCTOR_CALLBACK_PORT);
-    context.pendingToken = token;
+    context.pendingToken = await authenticateInBrowser(context.targets.userPanelBaseUrl, DEFAULT_DOCTOR_CALLBACK_PORT);
 }
 export async function runSessionValidationProbe(context) {
-    const session = await fetchAuthenticatedJson(sessionSchema, new URL('/api/auth/current-session', context.targets.apiBaseUrl).href, context.pendingToken);
-    context.pendingSession = session;
+    context.pendingSession = await fetchAuthenticatedJson(sessionSchema, new URL('/api/auth/current-session', context.targets.apiBaseUrl).href, context.pendingToken);
 }
 export async function runProfileFetchProbe(context) {
     const profile = await fetchAuthenticatedJson(profileSchema, new URL('/api/profiles/me', context.targets.apiBaseUrl).href, context.pendingToken);

package/dist/cli/commands/doctor/probes/global/input-validation.js

@@ -1,15 +1,14 @@
 import { validateAndNormalizeUrls } from '../../utils.js';
 export async function runInputValidationProbe(context) {
-    const targets = validateAndNormalizeUrls(context.rawRpcUrl, context.rawUserPanelUrl);
-    context.targets = targets;
+    context.targets = validateAndNormalizeUrls(context.rawRpcUrl);
 }
 export async function runHostMismatchProbe(context) {
     const warnings = [];
-    if (context.targets.apiBaseUrl !== context.rawRpcUrl) {
+    if (new URL(context.targets.apiBaseUrl).origin !== new URL(context.rawRpcUrl).origin) {
         warnings.push({ label: 'api', value: context.rawRpcUrl });
     }
     if (context.targets.userPanelBaseUrl !== context.rawUserPanelUrl) {
-        warnings.push({ label: 'user panel', value: context.rawUserPanelUrl });
+        warnings.push({ label: 'user panel', value: context.rawUserPanelUrl ?? '' });
     }
     if (warnings.length > 0) {
         return {

package/dist/cli/commands/doctor/probes/global/well-known.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorContext, ProbeOutput } from '../../types.js';
+export declare function runWellKnownProbe(context: DoctorContext): Promise<ProbeOutput>;

package/dist/cli/commands/doctor/probes/global/well-known.js

@@ -0,0 +1,16 @@
+import { fetchPrividiumConfig } from '#sdk';
+export async function runWellKnownProbe(context) {
+    const prividiumInfo = await fetchPrividiumConfig(new URL(context.targets.apiBaseUrl).origin);
+    context.targets = {
+        ...context.targets,
+        userPanelBaseUrl: new URL(prividiumInfo.userPanelUrl).origin
+    };
+    context.apiVersion = prividiumInfo.version;
+    return {
+        values: [
+            { label: 'User Panel', value: prividiumInfo.userPanelUrl, inline: true },
+            { label: 'Chain', value: prividiumInfo.chainName, inline: true },
+            { label: 'Version', value: prividiumInfo.version, inline: true }
+        ]
+    };
+}

package/dist/cli/commands/doctor/probes/global.js

@@ -1,6 +1,7 @@
 import { passed } from '../utils.js';
 import { runHostMismatchProbe, runInputValidationProbe } from './global/input-validation.js';
 import { runApiHealthProbe, runCallbackPortProbe, runPublicRpcProbe, runUserPanelReachabilityProbe } from './global/reachability.js';
+import { runWellKnownProbe } from './global/well-known.js';
 export const globalStage = {
     id: 'global',
     title: 'Global',
@@ -22,11 +23,18 @@ export const globalStage = {
             runIf: passed('input-validation', 'Input validation failed'),
             run: runHostMismatchProbe
         },
+        {
+            id: 'well-known',
+            label: 'Prividium configuration',
+            progressMessage: 'Fetching Prividium configuration',
+            runIf: passed('input-validation', 'Input validation failed'),
+            run: runWellKnownProbe
+        },
         {
             id: 'user-panel-reachable',
             label: 'User Panel reachability',
             progressMessage: 'Checking User Panel reachability',
-            runIf: passed('input-validation', 'Input validation failed'),
+            runIf: passed('well-known', 'Could not discover User Panel url'),
             run: runUserPanelReachabilityProbe
         },
         {

package/dist/cli/commands/doctor/report/build.js

@@ -22,7 +22,9 @@ function buildSummaryBlock(context) {
             { label: 'Status', value: `${failCount} failed, ${skipCount} skipped, ${passCount} passed` },
             { label: 'API', value: context.targets?.apiBaseUrl ?? context.rawRpcUrl },
             ...(context.apiVersion ? [{ label: 'API Version', value: context.apiVersion }] : []),
-            { label: 'User Panel', value: context.targets?.userPanelBaseUrl ?? context.rawUserPanelUrl },
+            ...(context.targets?.userPanelBaseUrl
+                ? [{ label: 'User Panel', value: context.targets.userPanelBaseUrl }]
+                : []),
             { label: 'Time', value: new Date().toISOString() }
         ]
     };

package/dist/cli/commands/doctor/types.d.ts

@@ -8,7 +8,7 @@ export type Options = {
 };
 export type NormalizedTargets = {
     apiBaseUrl: string;
-    userPanelBaseUrl: string;
+    userPanelBaseUrl?: string;
 };
 export type ReportStatus = 'pass' | 'warn' | 'fail' | 'skip';
 export type ReportValue = {
@@ -59,7 +59,7 @@ export type AuthenticatedDoctorState = {
 };
 export type DoctorContext = {
     rawRpcUrl: string;
-    rawUserPanelUrl: string;
+    rawUserPanelUrl?: string;
     targets?: NormalizedTargets;
     authState?: AuthenticatedDoctorState;
     reportContext?: ReportContext;

package/dist/cli/commands/doctor/utils.d.ts

@@ -15,4 +15,4 @@ export declare function formatHexQuantity(value: string): string;
 export declare function shortenAddress(address: string): string;
 export declare function getRawReason(status: number, body: string): string;
 export declare function getThrownReason(error: unknown): string;
-export declare function validateAndNormalizeUrls(prividiumRpcUrl: string, userPanelUrl: string): NormalizedTargets;
+export declare function validateAndNormalizeUrls(prividiumRpcUrl: string): NormalizedTargets;

package/dist/cli/commands/doctor/utils.js

@@ -36,17 +36,12 @@ export function getRawReason(status, body) {
 export function getThrownReason(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function validateAndNormalizeUrls(prividiumRpcUrl, userPanelUrl) {
+export function validateAndNormalizeUrls(prividiumRpcUrl) {
     const apiParse = z.url().safeParse(prividiumRpcUrl);
     if (!apiParse.success) {
         throw new Error(`Invalid API url provided: ${prividiumRpcUrl}`);
     }
-    const panelParse = z.url().safeParse(userPanelUrl);
-    if (!panelParse.success) {
-        throw new Error(`Invalid user panel url provided: ${userPanelUrl}`);
-    }
     return {
-        apiBaseUrl: `${new URL(prividiumRpcUrl).origin}/rpc`,
-        userPanelBaseUrl: new URL(userPanelUrl).origin
+        apiBaseUrl: `${new URL(prividiumRpcUrl).origin}/rpc`
     };
 }

package/dist/cli/commands/doctor.js

@@ -8,19 +8,16 @@ import { buildDoctorReport } from './doctor/report/build.js';
 import { printReport } from './doctor/report/render.js';
 import { executeDoctorStages } from './doctor/stages.js';
 import { showPrividiumHeader } from './utils/show-prividium-header.js';
-import { gatherUrlConfig } from './utils/url-config.js';
+import { gatherApiUrl } from './utils/url-config.js';
 async function runDoctor(opts) {
     showPrividiumHeader();
     intro('Prividium™ Doctor');
-    const { prividiumRpcUrl, userPanelUrl } = await gatherUrlConfig({
+    const prividiumRpcUrl = await gatherApiUrl({
         configPath: opts.configPath,
-        rpcUrl: opts.rpcUrl,
-        userPanelUrl: opts.userPanelUrl,
-        rpcUrlLabel: 'prividium api'
+        apiUrl: opts.rpcUrl
     });
     const executionContext = {
         rawRpcUrl: prividiumRpcUrl,
-        rawUserPanelUrl: userPanelUrl,
         walletAddresses: [],
         walletApiAvailable: false,
         results: []
@@ -52,13 +49,15 @@ export const addDoctor = (cli) => {
     return cli.command('doctor', 'Runs Prividium Doctor checks', (yargs) => yargs
         .option('rpcUrl', {
         alias: ['prividium-api-url', 'rpc-url', 'r'],
-        description: 'Target Prividium™ API URL or /rpc URL. Takes precedence over config file and env.',
+        description: 'Target Prividium™ API URL or /rpc URL. The User Panel url and chain config are fetched from /.well-known/prividium on this host.',
         demandOption: false,
         type: 'string'
     })
         .option('userPanelUrl', {
         alias: ['user-panel-url', 'u'],
-        description: 'User panel URL for browser authentication. Takes precedence over config file and env.',
+        description: 'Specifies the User Panel url to check. When provided, this value takes priority and the User Panel url is not fetched from /.well-known/prividium.',
+        demandOption: false,
+        deprecated: 'fetched automatically from Prividium™ API.',
         type: 'string'
     }), async (args) => {
         try {

package/dist/cli/commands/proxy.js

@@ -1,12 +1,11 @@
-import { intro, log, text } from '@clack/prompts';
+import { intro, log } from '@clack/prompts';
 import color from 'kleur';
 import { privateKeyToAccount } from 'viem/accounts';
-import { z } from 'zod';
 import { MemoryStorage, SiweAuth, TokenManager } from '#sdk/siwe';
 import { CreationWorkflow } from '../server/connection-workflow.js';
 import { buildServer } from '../server/server.js';
 import { showPrividiumHeader } from './utils/show-prividium-header.js';
-import { gatherApiUrl } from './utils/url-config.js';
+import { gatherApiUrl, getUserPanelUrl } from './utils/url-config.js';
 const DEFAULT_PORT = 24101;
 const PRIVATE_KEY_REGEX = /^0x[0-9a-fA-F]{64}$/;
 function checkHostAndPortWarnings(host, port, allowExternalAccess) {
@@ -26,64 +25,6 @@ function checkHostAndPortWarnings(host, port, allowExternalAccess) {
         }
     }
 }
-const wellKnownMetadataSchema = z.object({
-    apiUrl: z.string().optional()
-});
-// Fetches /.well-known/prividium from the User Panel and returns its apiUrl.
-async function discoverApiUrlFromUserPanel(userPanelUrl) {
-    const wellKnownUrl = new URL('/.well-known/prividium', userPanelUrl).toString();
-    let response;
-    try {
-        response = await fetch(wellKnownUrl, { signal: AbortSignal.timeout(5000) });
-    }
-    catch (error) {
-        throw new Error(`Could not reach User Panel at ${userPanelUrl}.\n` +
-            `  ${error instanceof Error ? error.message : String(error)}\n` +
-            '  Please verify the URL is correct and the User Panel is running.');
-    }
-    if (!response.ok) {
-        throw new Error(`User Panel at ${userPanelUrl} did not return /.well-known/prividium (HTTP ${response.status}).\n` +
-            '  Please verify the URL points to a Prividium™ User Panel, or pass --api-url directly.');
-    }
-    let json;
-    try {
-        json = await response.json();
-    }
-    catch {
-        throw new Error(`User Panel at ${userPanelUrl} returned non-JSON for /.well-known/prividium.\n` +
-            '  Please verify the URL points to a Prividium™ User Panel, or pass --api-url directly.');
-    }
-    const parsed = wellKnownMetadataSchema.safeParse(json);
-    if (!parsed.success || !parsed.data.apiUrl) {
-        throw new Error(`User Panel at ${userPanelUrl} did not advertise an apiUrl in /.well-known/prividium.\n` +
-            '  Please pass --api-url directly.');
-    }
-    return parsed.data.apiUrl;
-}
-async function resolveUserPanelUrl(opts) {
-    const explicit = opts.userPanelUrl ?? process.env.USER_PANEL_URL;
-    if (explicit) {
-        const res = z.url().safeParse(explicit);
-        if (!res.success) {
-            throw new Error(`Invalid user panel url provided: ${explicit}`);
-        }
-        log.info(`Using user panel url: ${explicit}`);
-        return explicit;
-    }
-    const prompted = await text({
-        message: 'Please insert your Prividium™ User Panel url',
-        validate(value) {
-            const parsed = z.url().safeParse(value);
-            if (!parsed.success) {
-                return 'Please provide a valid url';
-            }
-        }
-    });
-    if (typeof prompted === 'symbol') {
-        throw new Error('Canceled by the user');
-    }
-    return prompted;
-}
 async function startServerWithPrivateKey(opts) {
     const privateKey = opts.privateKey;
     if (!PRIVATE_KEY_REGEX.test(privateKey)) {
@@ -143,17 +84,12 @@ async function startServerWithPrivateKey(opts) {
 async function startServer(opts) {
     const workflow = new CreationWorkflow(opts.host, opts.port);
     workflow.start();
-    const userPanelUrl = await resolveUserPanelUrl(opts);
-    let apiUrl;
-    if (opts.apiUrl) {
-        apiUrl = opts.apiUrl;
-        log.info(`Using Prividium™ API url: ${apiUrl}`);
-    }
-    else {
-        log.info('Discovering API URL from User Panel...');
-        apiUrl = await discoverApiUrlFromUserPanel(userPanelUrl);
-        log.info(`Using Prividium™ API url: ${apiUrl}`);
-    }
+    const apiUrl = await gatherApiUrl({
+        configPath: opts.configPath,
+        apiUrl: opts.apiUrl,
+        logProvidedUrls: true
+    });
+    const userPanelUrl = await getUserPanelUrl(opts.userPanelUrl, apiUrl);
     checkHostAndPortWarnings(opts.host, opts.port, opts.allowExternalAccess);
     const serverUrl = `http://${opts.host}:${opts.port}`;
     const app = buildServer({
@@ -184,13 +120,15 @@ export const addProxy = (cli) => {
     return cli.command('proxy', 'Starts authenticated rpc proxy server', (yargs) => yargs
         .option('apiUrl', {
         alias: ['api-url', 'rpc-url', 'r'],
-        description: 'Specifies target Prividium™ API url. Required with --private-key.',
+        description: 'Specifies target Prividium™ API url. The User Panel url is fetched from /.well-known/prividium on this host.',
         demandOption: false,
         type: 'string'
     })
         .option('userPanelUrl', {
         alias: ['user-panel-url', 'u'],
-        description: 'Specifies the User Panel url for browser-based login. If --api-url is omitted, it is fetched from the User Panel via /.well-known/prividium.',
+        description: 'Specifies the User Panel url for browser-based login. When provided, this value takes priority and the User Panel url is not fetched from /.well-known/prividium.',
+        demandOption: false,
+        deprecated: 'fetched automatically from Prividium™ API.',
         type: 'string'
     })
         .option('configPath', {

package/dist/cli/commands/utils/url-config.d.ts

@@ -4,15 +4,5 @@ type GatherApiUrlOptions = {
     logProvidedUrls?: boolean;
 };
 export declare function gatherApiUrl({ configPath, apiUrl, logProvidedUrls }: GatherApiUrlOptions): Promise<string>;
-type GatherUrlConfigOptions = {
-    configPath?: string;
-    rpcUrl?: string;
-    rpcUrlLabel: string;
-    logProvidedUrls?: boolean;
-    userPanelUrl?: string;
-};
-export declare function gatherUrlConfig({ configPath, rpcUrl, userPanelUrl, rpcUrlLabel, logProvidedUrls }: GatherUrlConfigOptions): Promise<{
-    prividiumRpcUrl: string;
-    userPanelUrl: string;
-}>;
+export declare function getUserPanelUrl(userInput: string | undefined, apiUrl: string): Promise<string>;
 export {};

package/dist/cli/commands/utils/url-config.js

@@ -1,10 +1,10 @@
 import { confirm, log, text } from '@clack/prompts';
 import { z } from 'zod';
+import { fetchPrividiumConfig } from '#sdk';
 import { ConfigFile } from '../../server/config-file.js';
 const envSchema = z.object({
     PRIVIDIUM_API_URL: z.string().optional(),
-    PRIVIDIUM_RPC_URL: z.string().optional(),
-    USER_PANEL_URL: z.string().optional()
+    PRIVIDIUM_RPC_URL: z.string().optional()
 });
 async function askForUrl(maybeUrl, name, logProvidedUrls) {
     if (maybeUrl !== undefined) {
@@ -35,7 +35,7 @@ export async function gatherApiUrl({ configPath, apiUrl, logProvidedUrls = false
     const config = new ConfigFile(configPath);
     const configData = config.read();
     const env = envSchema.parse(process.env);
-    const givenApiUrl = apiUrl ?? env.PRIVIDIUM_API_URL ?? configData.apiUrl;
+    const givenApiUrl = apiUrl ?? env.PRIVIDIUM_API_URL ?? env.PRIVIDIUM_RPC_URL ?? configData.apiUrl;
     const { url: resolvedApiUrl, prompted } = await askForUrl(givenApiUrl, 'Prividium™ API', logProvidedUrls);
     if (prompted) {
         const confirmation = await confirm({
@@ -47,21 +47,20 @@ export async function gatherApiUrl({ configPath, apiUrl, logProvidedUrls = false
     }
     return resolvedApiUrl;
 }
-export async function gatherUrlConfig({ configPath, rpcUrl, userPanelUrl, rpcUrlLabel, logProvidedUrls = false }) {
-    const config = new ConfigFile(configPath);
-    const configData = config.read();
-    const env = envSchema.parse(process.env);
-    const givenRpcUrl = rpcUrl ?? env.PRIVIDIUM_API_URL ?? env.PRIVIDIUM_RPC_URL ?? configData.apiUrl;
-    const givenUserPanelUrl = userPanelUrl ?? env.USER_PANEL_URL;
-    const { url: prividiumRpcUrl, prompted: promptedRpc } = await askForUrl(givenRpcUrl, rpcUrlLabel, logProvidedUrls);
-    const { url: resolvedUserPanelUrl, prompted: promptedPanel } = await askForUrl(givenUserPanelUrl, 'user panel', logProvidedUrls);
-    if (promptedRpc || promptedPanel) {
-        const confirmation = await confirm({
-            message: 'Do you want to store this config for future usages?'
-        });
-        if (confirmation) {
-            config.write({ apiUrl: prividiumRpcUrl });
+export async function getUserPanelUrl(userInput, apiUrl) {
+    let userPanelUrl;
+    if (userInput !== undefined) {
+        const parsed = z.url().safeParse(userInput);
+        if (!parsed.success) {
+            throw new Error(`Invalid User Panel url provided: ${userInput}`);
         }
+        userPanelUrl = parsed.data;
+    }
+    else {
+        log.info('Fetching configuration from Prividium™ API...');
+        const prividiumInfo = await fetchPrividiumConfig(apiUrl);
+        userPanelUrl = prividiumInfo.userPanelUrl;
     }
-    return { prividiumRpcUrl, userPanelUrl: resolvedUserPanelUrl };
+    log.info(`Using User Panel url: ${userPanelUrl}`);
+    return userPanelUrl;
 }

package/dist/cli/server/config-file.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 declare const schemas: {
     readonly latest: z.ZodObject<{
-        userPanelUrl: z.ZodOptional<z.ZodString>;
         apiUrl: z.ZodOptional<z.ZodString>;
         l1RpcUrl: z.ZodOptional<z.ZodString>;
         localZksyncOsRpcUrl: z.ZodOptional<z.ZodString>;
@@ -13,11 +12,6 @@ declare const schemas: {
     }, z.core.$strip>;
 };
 declare const PROMPTS_FOR_CONFIGS: {
-    readonly userPanelUrl: {
-        readonly msg: "Please insert your Prividium™ User Panel url";
-        readonly retry: "Please provide a valid url";
-        readonly schema: z.ZodURL;
-    };
     readonly apiUrl: {
         readonly msg: "Please insert your Prividium™ api url";
         readonly retry: "Please provide a valid url";

package/dist/cli/server/config-file.js

@@ -16,7 +16,6 @@ const dirs = appDirsFn({ appName: 'prividium-proxy' });
 // key, then change `latest` to the new shape and add a branch in `migrate()`.
 const schemas = {
     latest: z.object({
-        userPanelUrl: z.string().optional(),
         apiUrl: z.string().optional(),
         l1RpcUrl: z.string().optional(),
         localZksyncOsRpcUrl: z.string().optional(),
@@ -31,15 +30,9 @@ const ENV_VARS_FOR_CONFIG = {
     apiUrl: 'PRIVIDIUM_API_URL',
     l1RpcUrl: 'L1_RPC_URL',
     diamondAddress: 'ZSYNCOS_L1_DIAMOND',
-    userPanelUrl: 'USER_PANEL_URL',
     localZksyncOsRpcUrl: 'LOCAL_ZKSYNCOS_RPC_URL'
 };
 const PROMPTS_FOR_CONFIGS = {
-    userPanelUrl: {
-        msg: 'Please insert your Prividium™ User Panel url',
-        retry: 'Please provide a valid url',
-        schema: z.url()
-    },
     apiUrl: {
         msg: 'Please insert your Prividium™ api url',
         retry: 'Please provide a valid url',
@@ -100,13 +93,13 @@ export class ConfigFile {
     write(config) {
         const dir = path.parse(this.filePath).dir;
         mkdirSync(dir, { recursive: true });
-        writeFileSync(this.filePath, JSON.stringify({ latest: config }));
+        writeFileSync(this.filePath, JSON.stringify(config));
     }
     partialWrite(newConfig) {
         const old = this.read();
         const dir = path.parse(this.filePath).dir;
         mkdirSync(dir, { recursive: true });
-        writeFileSync(this.filePath, JSON.stringify({ latest: { ...old, ...newConfig } }));
+        writeFileSync(this.filePath, JSON.stringify({ ...old, ...newConfig }));
     }
     remove() {
         if (existsSync(this.filePath)) {

package/dist/sdk/admin-api/index.d.ts

@@ -10,5 +10,5 @@ export declare function createAdminMethods(deps: {
     prividiumApiBaseUrl: string;
 }): AdminMethods;
 export type { ContractsAdminMethods } from './contracts.js';
-export type { AdminContract, AdminContractCreate, AdminUser, AdminUserUpdate } from './types.js';
+export type { AdminContract, AdminContractCreate, AdminUser, AdminUserUpdate, AdminUserUpdateInput } from './types.js';
 export type { UsersAdminMethods } from './users.js';

package/dist/sdk/admin-api/types.d.ts

@@ -33,16 +33,11 @@ export interface AdminUser {
     wallets: Array<AdminUserWallet>;
 }
 export interface AdminUserUpdate {
-    id?: string;
-    oidcSub?: string | null;
-    displayName?: string;
-    source?: AdminUserSource;
-    walletToken?: string | null;
-    createdAt?: unknown;
-    updatedAt?: unknown;
-    roles?: Array<string>;
-    wallets?: Array<string>;
+    displayName: string;
+    roles: Array<string>;
+    wallets: Array<string>;
 }
+export type AdminUserUpdateInput = Partial<AdminUserUpdate>;
 export interface AdminDisclosedAddress {
     address: string;
 }

package/dist/sdk/admin-api/users.d.ts

@@ -1,8 +1,8 @@
 import type { ApiCaller } from '../chain-core.js';
-import type { AdminUser, AdminUserUpdate } from './types.js';
+import type { AdminUser, AdminUserUpdateInput } from './types.js';
 export interface UsersAdminMethods {
     getById(userId: string): Promise<AdminUser>;
-    update(userId: string, params: AdminUserUpdate): Promise<AdminUser>;
+    update(userId: string, params: AdminUserUpdateInput): Promise<AdminUser>;
 }
 export declare function createUsersAdminMethods(deps: {
     prividiumApiCall: ApiCaller;

package/dist/sdk/admin-api/users.js

@@ -2,12 +2,26 @@ import { adminUserSchema } from './schemas.js';
 export function createUsersAdminMethods(deps) {
     const { prividiumApiCall, prividiumApiBaseUrl } = deps;
     const baseUrl = (id) => `${prividiumApiBaseUrl}/api/users/${encodeURIComponent(id)}`;
+    const getById = (userId) => prividiumApiCall(adminUserSchema, baseUrl(userId), 'GET');
     return {
-        async getById(userId) {
-            return prividiumApiCall(adminUserSchema, baseUrl(userId), 'GET');
-        },
+        getById,
         async update(userId, params) {
-            return prividiumApiCall(adminUserSchema, baseUrl(userId), 'PUT', JSON.stringify(params));
+            // PUT /users/{id} is a full replacement. To keep partial updates working,
+            // fetch the current user and merge in any omitted fields before sending.
+            // When the caller already provides every field, skip the extra round-trip.
+            let body;
+            if (params.displayName !== undefined && params.roles !== undefined && params.wallets !== undefined) {
+                body = { displayName: params.displayName, roles: params.roles, wallets: params.wallets };
+            }
+            else {
+                const current = await getById(userId);
+                body = {
+                    displayName: params.displayName ?? current.displayName,
+                    roles: params.roles ?? current.roles.map((role) => role.roleName),
+                    wallets: params.wallets ?? current.wallets.map((wallet) => wallet.walletAddress)
+                };
+            }
+            return prividiumApiCall(adminUserSchema, baseUrl(userId), 'PUT', JSON.stringify(body));
         }
     };
 }

package/dist/sdk/index.d.ts

@@ -9,3 +9,4 @@ export type { AddNetworkParams, ContractAbiResponse, PopupOptions, PrividiumChai
 export { AUTH_ERRORS, STORAGE_KEYS } from './types.js';
 export type { UserTokenVerifyError, UserTokenVerifyResult, VerifyUserAccessTokenOptions } from './verify-user-access-token.js';
 export { verifyUserAccessToken } from './verify-user-access-token.js';
+export { type FetchPrividiumConfigOptions, fetchPrividiumConfig, type PrividiumSystemInfo, PrividiumWellKnownError, type PrividiumWellKnownErrorKind, prividiumSystemInfoSchema } from './well-known.js';

package/dist/sdk/index.js

@@ -7,3 +7,4 @@ export { LocalStorage, TokenManager } from './storage.js';
 export { generateRandomState } from './token-utils.js';
 export { AUTH_ERRORS, STORAGE_KEYS } from './types.js';
 export { verifyUserAccessToken } from './verify-user-access-token.js';
+export { fetchPrividiumConfig, PrividiumWellKnownError, prividiumSystemInfoSchema } from './well-known.js';

package/dist/sdk/siwe.d.ts

@@ -1,4 +1,4 @@
-export type { AdminContract, AdminContractCreate, AdminMethods, AdminUser, AdminUserUpdate, ContractsAdminMethods, UsersAdminMethods } from './admin-api/index.js';
+export type { AdminContract, AdminContractCreate, AdminMethods, AdminUser, AdminUserUpdate, AdminUserUpdateInput, ContractsAdminMethods, UsersAdminMethods } from './admin-api/index.js';
 export { createPrividiumClient } from './create-prividium-client.js';
 export { MemoryStorage } from './memory-storage.js';
 export { FORBIDDEN_ERROR_CODE, METHOD_NOT_FOUND_ERROR_CODE, UNAUTHORIZED_ERROR_CODE } from './rpc-error-codes.js';

package/dist/sdk/well-known.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const prividiumSystemInfoSchema: z.ZodObject<{
+    blockExplorerUrl: z.ZodURL;
+    chainId: z.ZodTemplateLiteral<`0x${string}`>;
+    chainName: z.ZodString;
+    baseToken: z.ZodObject<{
+        name: z.ZodString;
+        symbol: z.ZodString;
+        decimals: z.ZodNumber;
+        l1Address: z.ZodNullable<z.ZodTemplateLiteral<`0x${string}`>>;
+    }, z.core.$strip>;
+    rpcUrl: z.ZodURL;
+    userPanelUrl: z.ZodURL;
+    version: z.ZodString;
+    l1ChainId: z.ZodTemplateLiteral<`0x${string}`>;
+    l1ChainName: z.ZodString;
+}, z.core.$strip>;
+export type PrividiumSystemInfo = z.infer<typeof prividiumSystemInfoSchema>;
+export type PrividiumWellKnownErrorKind = 'network' | 'http' | 'schema';
+export declare class PrividiumWellKnownError extends Error {
+    readonly kind: PrividiumWellKnownErrorKind;
+    constructor(kind: PrividiumWellKnownErrorKind, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export type FetchPrividiumConfigOptions = {
+    signal?: AbortSignal;
+    fetch?: typeof fetch;
+};
+export declare function fetchPrividiumConfig(apiUrl: string, opts?: FetchPrividiumConfigOptions): Promise<PrividiumSystemInfo>;

package/dist/sdk/well-known.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+const hexSchema = z.templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]+$/)]);
+const addressSchema = z.templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]{40}$/)]);
+export const prividiumSystemInfoSchema = z.object({
+    blockExplorerUrl: z.url(),
+    chainId: hexSchema,
+    chainName: z.string(),
+    baseToken: z.object({
+        name: z.string(),
+        symbol: z.string(),
+        decimals: z.number(),
+        l1Address: addressSchema.nullable()
+    }),
+    rpcUrl: z.url(),
+    userPanelUrl: z.url(),
+    version: z.string(),
+    l1ChainId: hexSchema,
+    l1ChainName: z.string()
+});
+const wellKnownSchema = z.object({
+    v1: prividiumSystemInfoSchema
+});
+export class PrividiumWellKnownError extends Error {
+    kind;
+    constructor(kind, message, options) {
+        super(message, options);
+        this.name = 'PrividiumWellKnownError';
+        this.kind = kind;
+    }
+}
+const DEFAULT_TIMEOUT_MS = 5000;
+export async function fetchPrividiumConfig(apiUrl, opts) {
+    const url = new URL('/.well-known/prividium', apiUrl).toString();
+    const doFetch = opts?.fetch ?? fetch;
+    const signal = opts?.signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+    let response;
+    try {
+        response = await doFetch(url, { signal });
+    }
+    catch (cause) {
+        throw new PrividiumWellKnownError('network', `Could not reach ${url}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+    if (!response.ok) {
+        throw new PrividiumWellKnownError('http', `Unexpected HTTP ${response.status} from ${url}`);
+    }
+    let json;
+    try {
+        json = await response.json();
+    }
+    catch (cause) {
+        throw new PrividiumWellKnownError('schema', `Response from ${url} was not valid JSON`, { cause });
+    }
+    const parsed = wellKnownSchema.safeParse(json);
+    if (!parsed.success) {
+        throw new PrividiumWellKnownError('schema', `Response from ${url} did not match the Prividium well-known shape: ${parsed.error.message}`, { cause: parsed.error });
+    }
+    return parsed.data.v1;
+}