Manage Auth Tokens Programmatically

import type { Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const PRIVIDIUM_API_BASE_URL = process.env.PRIVIDIUM_API_BASE_URL ?? 'http://localhost:8000';
const DOMAIN = process.env.DOMAIN ?? 'localhost:3000';
const PRIVATE_KEY = process.env.PRIVATE_KEY;

let currentToken: string;
let tokenExpiresAt = new Date(0);

async function apiCall(path: string, init = {}) {
    const url = new URL(path, PRIVIDIUM_API_BASE_URL);
    const response = await fetch(url, init);

    if (!response.ok) {
        const detail = await response.text();
        throw new Error(`Request failed (${response.status}) ${path}: ${detail}`);
    }

    return response.json();
}

async function authenticate() {
    if (!PRIVATE_KEY) throw new Error('Missing PRIVATE_KEY in environment');
    const account = privateKeyToAccount(PRIVATE_KEY as Hex);

    // 1. Request a SIWE message
    const siweData = await apiCall('/api/siwe-messages', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            address: account.address,
            domain: DOMAIN
        })
    });

    // 2. Sign the returned message
    const signature = await account.signMessage({
        message: siweData.msg
    });

    // 3. Exchange for a session token
    const loginData = await apiCall('/api/auth/login/crypto-native', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            message: siweData.msg,
            signature,
            nonceToken: siweData.nonceToken
        })
    });

    // 4. Use the token in Authorization: Bearer <token> headers
    currentToken = loginData.token;
    tokenExpiresAt = new Date(loginData.expiresAt);
    console.log('Token expires at:', tokenExpiresAt.toISOString());

    return currentToken;
}

async function ensureAuthenticated() {
    if (!currentToken || new Date() >= tokenExpiresAt) {
        console.log('Session missing or expired. Authenticating...');
        await authenticate();
    }
}

async function fetchUserProfile() {
    await ensureAuthenticated();

    const user = await apiCall('/api/profiles/me', {
        method: 'GET',
        headers: {
            Authorization: `Bearer ${currentToken}`
        }
    });

    console.log('Authenticated user:', user.displayName ?? user.id);
    return user;
}

async function callRpc(method: string, params = []) {
    await ensureAuthenticated();

    const rpcResponse = await apiCall('/rpc', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            Authorization: `Bearer ${currentToken}`
        },
        body: JSON.stringify({
            jsonrpc: '2.0',
            id: 1,
            method,
            params
        })
    });

    if (rpcResponse.error) throw new Error(`RPC ${method} failed: ${JSON.stringify(rpcResponse.error)}`);

    return rpcResponse.result;
}

export async function main() {
    const token = await authenticate();
    console.log('Authorization header:', `Bearer ${token}`);

    await fetchUserProfile();

    const chainId = await callRpc('eth_chainId');
    console.log('Authenticated RPC chain ID:', Number(chainId));
}

main().catch(console.error);

import { createPrividiumClient } from 'prividium';
import { createPrividiumSiweChain, type PrividiumSiweConfig } from 'prividium/siwe';
import { defineChain, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';


const PRIVATE_KEY = process.env.PRIVATE_KEY;
const PRIVIDIUM_API_BASE_URL = process.env.PRIVIDIUM_API_BASE_URL ?? 'http://localhost:8000';
const DOMAIN = process.env.DOMAIN ?? 'localhost:3000';
const CHAIN_ID = Number(process.env.CHAIN_ID ?? '6565');

export async function main() {
    if (!PRIVATE_KEY) throw new Error('MISSING PRIVATE KEY');

    const account = privateKeyToAccount(PRIVATE_KEY as Hex) as unknown as PrividiumSiweConfig['account'];
    const chain = defineChain({
        id: CHAIN_ID,
        name: 'Prividium Local',
        nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
        rpcUrls: { default: { http: [] } }
    }) as unknown as PrividiumSiweConfig['chain'];

    const prividium = createPrividiumSiweChain({
        account,
        chain,
        prividiumApiBaseUrl: PRIVIDIUM_API_BASE_URL,
        domain: DOMAIN,
        onReauthenticate: () => {
            console.info('Prividium session refreshed');
        }
    });

    const client = createPrividiumClient({
        chain: prividium.chain,
        transport: prividium.transport,
        account: prividium.address
    });

    const session = await prividium.authorize();
    console.log('Token expires at:', session.expiresAt.toISOString());

    const user = await prividium.fetchUser();
    console.log('Authenticated user:', user.displayName ?? user.id);

    const headers = prividium.getAuthHeaders();
    if (!headers) {
        throw new Error('Expected auth headers after authorize()');
    }
    console.log('Authorization header:', headers.Authorization);

    const chainId = await client.getChainId();
    console.log('Authenticated RPC chain ID:', chainId);

    return { prividium, client };
}

main().catch(console.error);