prividium 0.0.1-beta → 0.0.2-beta

package/README.md

@@ -1,7 +1,7 @@
 # Prividium SDK
 
-A TypeScript SDK for integrating with Prividium's authorization system, providing seamless authentication and secure RPC
-communication for blockchain applications.
+A TypeScript SDK for integrating with the Prividium authorization system, providing seamless authentication and secure
+RPC communication for blockchain applications.
 
 ## Features
 
@@ -33,6 +33,8 @@ const prividiumChain = defineChain({
 });
 
 // Create SDK instance
+// Note: replace the URLs and clientId with your actual values
+// Make sure clientId is registered in User Panel (OAUTH_CLIENTS)
 const prividium = createPrividiumChain({
   clientId: 'your-client-id',
   chain: prividiumChain,
@@ -70,7 +72,60 @@ const balance = await client.getBalance({
 });
 ```
 
-### 4. Setup OAuth Callback Page
+### 4. Sending Transactions with Injected Wallets (MetaMask)
+
+Before sending transactions through injected wallets, you need to add the Prividium network and enable wallet RPC for
+each transaction.
+
+```typescript
+import { createWalletClient, custom, encodeFunctionData } from 'viem';
+
+// Add Prividium network to MetaMask
+await prividium.addNetworkToWallet();
+
+// Create wallet client for MetaMask
+const walletClient = createWalletClient({
+  chain: prividium.chain,
+  transport: custom(window.ethereum)
+});
+
+const [address] = await walletClient.getAddresses();
+
+// Prepare transaction with viem
+const greeterContract = '0x...';
+const request = await walletClient.prepareTransactionRequest({
+  account: address,
+  to: greeterContract,
+  data: encodeFunctionData({
+    abi: [
+      {
+        name: 'setGreeting',
+        type: 'function',
+        inputs: [{ name: 'greeting', type: 'string' }],
+        outputs: []
+      }
+    ],
+    functionName: 'setGreeting',
+    args: ['Hello, Prividium!']
+  })
+});
+
+// Enable wallet token for this transaction
+await prividium.enableWalletToken({
+  walletAddress: address,
+  contractAddress: greeterContract,
+  nonce: Number(request.nonce),
+  calldata: request.data
+});
+
+// Send transaction through MetaMask
+const hash = await walletClient.sendTransaction(request);
+```
+
+**Note:** Call `enableWalletToken(...)` before each transaction. Permission is transaction-specific and expires after 1
+hour.
+
+### 5. Setup OAuth Callback Page
 
 The SDK requires a callback page to complete the authentication flow securely using `postMessage`. Create a callback
 page at the `redirectUrl` you configured:

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { createPrividiumChain } from './prividium-chain.js';
-export type { PrividiumConfig, PrividiumChain, PopupOptions, Storage, TokenData, UserProfile, UserRole } from './types.js';
+export type { PrividiumConfig, PrividiumChain, PopupOptions, Storage, TokenData, UserProfile, UserRole, AddNetworkParams } from './types.js';
 export { AUTH_ERRORS, STORAGE_KEYS } from './types.js';
 export { LocalStorage, TokenManager } from './storage.js';
 export { parseToken, isTokenExpired, generateRandomState } from './token-utils.js';

package/dist/prividium-chain.d.ts

@@ -1,2 +1,12 @@
 import { type PrividiumConfig, type PrividiumChain } from './types.js';
+declare global {
+    interface Window {
+        ethereum?: {
+            request: (args: {
+                method: string;
+                params?: unknown[];
+            }) => Promise<unknown>;
+        };
+    }
+}
 export declare function createPrividiumChain(config: PrividiumConfig): PrividiumChain;

package/dist/prividium-chain.js

@@ -93,6 +93,108 @@ export function createPrividiumChain(config) {
                 roles: userData.roles,
                 walletAddresses: userData.walletAddresses
             };
+        },
+        async getWalletToken() {
+            const headers = getAuthHeaders();
+            if (!headers) {
+                throw new Error('Authentication required. Please call authorize() first.');
+            }
+            const response = await fetch(`${config.permissionsApiBaseUrl}/api/wallet/personal-rpc-token`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers
+                }
+            });
+            if (response.status === 403) {
+                tokenManager.clearToken();
+                config.onAuthExpiry?.();
+                throw new Error('Authentication required. Please call authorize() first.');
+            }
+            if (!response.ok) {
+                throw new Error(`Failed to fetch wallet token: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            return data.token;
+        },
+        async getWalletRpcUrl() {
+            const walletToken = await this.getWalletToken();
+            // Extract base URL without /api path
+            const baseUrl = config.rpcUrl.replace(/\/rpc.*$/, '');
+            return `${baseUrl}/wallet/${walletToken}`;
+        },
+        async invalidateWalletToken() {
+            const headers = getAuthHeaders();
+            if (!headers) {
+                throw new Error('Authentication required. Please call authorize() first.');
+            }
+            const response = await fetch(`${config.permissionsApiBaseUrl}/api/wallet/invalidate`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to invalidate wallet token: ${response.status} ${response.statusText}`);
+            }
+            const result = (await response.json());
+            return result.newWalletToken;
+        },
+        async enableWalletToken(params) {
+            const headers = getAuthHeaders();
+            if (!headers) {
+                throw new Error('Authentication required. Please call authorize() first.');
+            }
+            const response = await fetch(`${config.permissionsApiBaseUrl}/api/wallet/enable`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers
+                },
+                body: JSON.stringify(params)
+            });
+            if (response.status === 403) {
+                tokenManager.clearToken();
+                config.onAuthExpiry?.();
+                throw new Error('Authentication required. Please call authorize() first.');
+            }
+            if (!response.ok) {
+                throw new Error(`Failed to enable wallet token: ${response.status} ${response.statusText}`);
+            }
+            const result = (await response.json());
+            return result;
+        },
+        async addNetworkToWallet(params) {
+            if (typeof window === 'undefined' || !window.ethereum) {
+                throw new Error('Wallet not detected. Please install a wallet extension to add network.');
+            }
+            const walletRpcUrl = await this.getWalletRpcUrl();
+            const chainIdHex = `0x${config.chain.id.toString(16)}`;
+            const networkParams = {
+                chainId: params?.chainId || chainIdHex,
+                chainName: params?.chainName || config.chain.name,
+                nativeCurrency: params?.nativeCurrency || {
+                    name: config.chain.nativeCurrency?.name || 'Ether',
+                    symbol: config.chain.nativeCurrency?.symbol || 'ETH',
+                    decimals: config.chain.nativeCurrency?.decimals || 18
+                },
+                rpcUrls: [walletRpcUrl],
+                blockExplorerUrls: params?.blockExplorerUrls ||
+                    (config.chain.blockExplorers?.default?.url ? [config.chain.blockExplorers.default.url] : undefined)
+            };
+            try {
+                if (!window.ethereum) {
+                    throw new Error('Wallet not detected');
+                }
+                await window.ethereum.request({
+                    method: 'wallet_addEthereumChain',
+                    params: [networkParams]
+                });
+            }
+            catch (error) {
+                throw new Error(`Failed to add network to wallet: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
         }
     };
 }

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { type Chain, type Transport } from 'viem';
+import { type Chain, type Transport, type Address, type Hex } from 'viem';
 import { type OauthScope } from './popup-auth.js';
 export interface Storage {
     getItem(key: string): string | null;
@@ -27,6 +27,26 @@ export interface UserProfile {
     roles: UserRole[];
     walletAddresses: string[];
 }
+export interface AddNetworkParams {
+    chainName?: string;
+    chainId: string;
+    nativeCurrency?: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    blockExplorerUrls?: string[];
+}
+export interface EnableWalletTokenParams {
+    walletAddress: Address;
+    contractAddress: Address;
+    nonce: number;
+    calldata: Hex;
+}
+export interface EnableWalletTokenResponse {
+    message: string;
+    activeUntil: string;
+}
 export interface PrividiumChain {
     chain: Chain;
     transport: Transport;
@@ -40,6 +60,11 @@ export interface PrividiumChain {
     isAuthorized(): boolean;
     getAuthHeaders(): Record<string, string> | null;
     fetchUser(): Promise<UserProfile>;
+    getWalletToken(): Promise<string>;
+    getWalletRpcUrl(): Promise<string>;
+    invalidateWalletToken(): Promise<string>;
+    enableWalletToken(params: EnableWalletTokenParams): Promise<EnableWalletTokenResponse>;
+    addNetworkToWallet(params?: AddNetworkParams): Promise<void>;
 }
 export interface TokenData {
     rawToken: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prividium",
-  "version": "0.0.1-beta",
+  "version": "0.0.2-beta",
   "exports": {
     ".": {
       "import": "./dist/index.js",