@sudobility/indexer_client 0.0.41 → 0.0.43

package/dist/network/IndexerClient.js

@@ -1,285 +1,156 @@
-import axios from 'axios';
+import { buildUrl, createAuthHeaders, createHeaders, handleApiError, } from '../utils/indexer-helpers';
 export class IndexerClient {
-    constructor(endpointUrl, dev = false, timeout = 30000) {
+    constructor(endpointUrl, networkClient, dev = false) {
         this.baseUrl = endpointUrl;
+        this.networkClient = networkClient;
         this.dev = dev;
-        this.timeout = timeout;
-    }
-    async get(url, options) {
-        return this.request(url, { ...options, method: 'GET' });
-    }
-    async post(url, body, options) {
-        return this.request(url, {
-            ...options,
-            method: 'POST',
-            body,
-        });
-    }
-    async put(url, body, options) {
-        return this.request(url, {
-            ...options,
-            method: 'PUT',
-            body,
-        });
-    }
-    async delete(url, options) {
-        return this.request(url, { ...options, method: 'DELETE' });
-    }
-    async request(url, options) {
-        const fullUrl = `${this.baseUrl}${url}`;
-        const axiosConfig = {
-            method: options?.method || 'GET',
-            url: fullUrl,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-                ...(this.dev && { 'x-dev': 'true' }),
-                ...options?.headers,
-            },
-            timeout: this.timeout,
-            signal: options?.signal,
-            withCredentials: false,
-        };
-        if (options?.body) {
-            if (typeof options.body === 'string') {
-                try {
-                    axiosConfig.data = JSON.parse(options.body);
-                }
-                catch {
-                    axiosConfig.data = options.body;
-                }
-            }
-            else {
-                axiosConfig.data = options.body;
-            }
-        }
-        try {
-            const response = await axios(axiosConfig);
-            return {
-                ok: response.status >= 200 && response.status < 300,
-                status: response.status,
-                statusText: response.statusText,
-                data: response.data,
-                headers: response.headers,
-                success: response.status >= 200 && response.status < 300,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        catch (error) {
-            if (error.response || error.request) {
-                if (error.response) {
-                    return {
-                        ok: false,
-                        status: error.response.status,
-                        statusText: error.response.statusText,
-                        data: error.response.data,
-                        headers: error.response.headers,
-                        success: false,
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                console.error('[IndexerClient] Network error details:', {
-                    message: error.message,
-                    code: error.code,
-                    url: fullUrl,
-                    method: axiosConfig.method,
-                });
-                throw new Error(`Indexer API request failed: ${error.message}`);
-            }
-            throw new Error(`Indexer API request failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
     }
     async validateUsername(username) {
-        const response = await this.get(`/users/${encodeURIComponent(username)}/validate`);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] validateUsername failed:', errorMessage);
-            throw new Error(`Failed to validate username: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/users/${encodeURIComponent(username)}/validate`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'validate username');
         }
         return response.data;
     }
     async getMessage(chainId, walletAddress, domain, url) {
+        const headers = createHeaders(this.dev);
         const queryParams = new URLSearchParams({
             chainId: chainId.toString(),
             domain,
             url,
         });
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/message?${queryParams.toString()}`);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getMessage failed:', errorMessage);
-            throw new Error(`Failed to get message: ${errorMessage}`);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/message?${queryParams.toString()}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get message');
         }
         return response.data;
     }
     async getPointsInfo() {
-        const response = await this.get('/points');
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getPointsInfo failed:', errorMessage);
-            throw new Error(`Failed to get points info: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, '/points'), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get points info');
         }
         return response.data;
     }
     async getPointsLeaderboard(count = 10) {
-        const response = await this.get(`/points/leaderboard/${count}`);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getPointsLeaderboard failed:', errorMessage);
-            throw new Error(`Failed to get points leaderboard: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/points/leaderboard/${count}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get points leaderboard');
         }
         return response.data;
     }
     async getPointsSiteStats() {
-        const response = await this.get('/points/site-stats');
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getPointsSiteStats failed:', errorMessage);
-            throw new Error(`Failed to get site stats: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, '/points/site-stats'), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get site stats');
         }
         return response.data;
     }
-    createAuthHeaders(auth) {
-        return {
-            'x-signature': auth.signature.replace(/[\r\n]/g, ''),
-            'x-message': encodeURIComponent(auth.message),
-            'x-signer': auth.signer,
-        };
-    }
     async getWalletAccounts(walletAddress, auth, referralCode) {
-        const headers = this.createAuthHeaders(auth);
-        if (referralCode) {
-            headers['x-referral'] = referralCode;
-        }
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/accounts`, { headers });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getWalletAccounts failed:', errorMessage);
-            throw new Error(`Failed to get wallet accounts: ${errorMessage}`);
+        const additionalHeaders = referralCode
+            ? { 'x-referral': referralCode }
+            : undefined;
+        const headers = createAuthHeaders(auth, this.dev, additionalHeaders);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/accounts`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get wallet accounts');
         }
         return response.data;
     }
     async getDelegatedTo(walletAddress, auth) {
-        const response = await this.get(`/delegations/from/${encodeURIComponent(walletAddress)}`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getDelegatedTo failed:', errorMessage);
-            throw new Error(`Failed to get delegation: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/delegations/from/${encodeURIComponent(walletAddress)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get delegation');
         }
         return response.data;
     }
     async getDelegatedFrom(walletAddress, auth) {
-        const response = await this.get(`/delegations/to/${encodeURIComponent(walletAddress)}`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getDelegatedFrom failed:', errorMessage);
-            throw new Error(`Failed to get delegators: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/delegations/to/${encodeURIComponent(walletAddress)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get delegators');
         }
         return response.data;
     }
     async createNonce(username, auth) {
-        const response = await this.post(`/users/${encodeURIComponent(username)}/nonce`, {}, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] createNonce failed:', errorMessage);
-            throw new Error(`Failed to create nonce: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, `/users/${encodeURIComponent(username)}/nonce`), {}, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'create nonce');
         }
         return response.data;
     }
     async getNonce(username, auth) {
-        const response = await this.get(`/users/${encodeURIComponent(username)}/nonce`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getNonce failed:', errorMessage);
-            throw new Error(`Failed to get nonce: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/users/${encodeURIComponent(username)}/nonce`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get nonce');
         }
         return response.data;
     }
     async getEntitlement(walletAddress, auth) {
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/entitlements/`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getEntitlement failed:', errorMessage);
-            throw new Error(`Failed to get entitlement: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/entitlements/`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get entitlement');
         }
         return response.data;
     }
     async getPointsBalance(walletAddress, auth) {
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/points`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getPointsBalance failed:', errorMessage);
-            throw new Error(`Failed to get points balance: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/points`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get points balance');
         }
         return response.data;
     }
     async getReferralCode(walletAddress, auth) {
-        const response = await this.post(`/wallets/${encodeURIComponent(walletAddress)}/referral`, {}, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error ||
-                response.data?.message ||
-                JSON.stringify(response.data) ||
-                `HTTP ${response.status}`;
-            console.error('[IndexerClient] getReferralCode failed:', errorMessage);
-            throw new Error(`Failed to get referral code: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/referral`), {}, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get referral code');
         }
         return response.data;
     }
     async getReferralStats(referralCode) {
-        const response = await this.post(`/referrals/${encodeURIComponent(referralCode)}/stats`, {});
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getReferralStats failed:', errorMessage);
-            throw new Error(`Failed to get referral stats: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, `/referrals/${encodeURIComponent(referralCode)}/stats`), {}, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get referral stats');
         }
         return response.data;
     }
     async getWalletNames(walletAddress, auth) {
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/names`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getWalletNames failed:', errorMessage);
-            throw new Error(`Failed to get wallet names: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/names`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get wallet names');
         }
         return response.data;
     }
     async resolveNameToAddress(name) {
-        const response = await this.get(`/wallets/named/${encodeURIComponent(name)}`);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] resolveNameToAddress failed:', errorMessage);
-            throw new Error(`Failed to resolve name: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/named/${encodeURIComponent(name)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'resolve name');
         }
         return response.data;
     }
     async createMailTemplate(walletAddress, auth, template) {
-        const response = await this.post(`/wallets/${encodeURIComponent(walletAddress)}/templates`, template, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] createMailTemplate failed:', errorMessage);
-            throw new Error(`Failed to create template: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/templates`), template, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'create template');
         }
         return response.data;
     }
     async getMailTemplates(walletAddress, auth, params) {
+        const headers = createAuthHeaders(auth, this.dev);
         const queryParams = new URLSearchParams();
         if (params?.active !== undefined) {
             queryParams.append('active', params.active.toString());
@@ -291,62 +162,47 @@ export class IndexerClient {
             queryParams.append('offset', params.offset.toString());
         }
         const queryString = queryParams.toString();
-        const url = `/wallets/${encodeURIComponent(walletAddress)}/templates${queryString ? `?${queryString}` : ''}`;
-        const response = await this.get(url, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getMailTemplates failed:', errorMessage);
-            throw new Error(`Failed to get templates: ${errorMessage}`);
+        const path = `/wallets/${encodeURIComponent(walletAddress)}/templates${queryString ? `?${queryString}` : ''}`;
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, path), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get templates');
         }
         return response.data;
     }
     async getMailTemplate(walletAddress, templateId, auth) {
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/templates/${encodeURIComponent(templateId)}`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getMailTemplate failed:', errorMessage);
-            throw new Error(`Failed to get template: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/templates/${encodeURIComponent(templateId)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get template');
         }
         return response.data;
     }
     async updateMailTemplate(walletAddress, templateId, auth, updates) {
-        const response = await this.put(`/wallets/${encodeURIComponent(walletAddress)}/templates/${encodeURIComponent(templateId)}`, updates, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] updateMailTemplate failed:', errorMessage);
-            throw new Error(`Failed to update template: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.put(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/templates/${encodeURIComponent(templateId)}`), updates, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'update template');
         }
         return response.data;
     }
     async deleteMailTemplate(walletAddress, templateId, auth) {
-        const response = await this.delete(`/wallets/${encodeURIComponent(walletAddress)}/templates/${encodeURIComponent(templateId)}`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] deleteMailTemplate failed:', errorMessage);
-            throw new Error(`Failed to delete template: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.delete(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/templates/${encodeURIComponent(templateId)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'delete template');
         }
         return response.data;
     }
     async createWebhook(walletAddress, auth, webhook) {
-        const response = await this.post(`/wallets/${encodeURIComponent(walletAddress)}/webhooks`, webhook, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] createWebhook failed:', errorMessage);
-            throw new Error(`Failed to create webhook: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/webhooks`), webhook, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'create webhook');
         }
         return response.data;
     }
     async getWebhooks(walletAddress, auth, params) {
+        const headers = createAuthHeaders(auth, this.dev);
         const queryParams = new URLSearchParams();
         if (params?.active !== undefined) {
             queryParams.append('active', params.active.toString());
@@ -358,68 +214,57 @@ export class IndexerClient {
             queryParams.append('offset', params.offset.toString());
         }
         const queryString = queryParams.toString();
-        const url = `/wallets/${encodeURIComponent(walletAddress)}/webhooks${queryString ? `?${queryString}` : ''}`;
-        const response = await this.get(url, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getWebhooks failed:', errorMessage);
-            throw new Error(`Failed to get webhooks: ${errorMessage}`);
+        const path = `/wallets/${encodeURIComponent(walletAddress)}/webhooks${queryString ? `?${queryString}` : ''}`;
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, path), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get webhooks');
         }
         return response.data;
     }
     async getWebhook(walletAddress, webhookId, auth) {
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/webhooks/${encodeURIComponent(webhookId)}`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getWebhook failed:', errorMessage);
-            throw new Error(`Failed to get webhook: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/webhooks/${encodeURIComponent(webhookId)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get webhook');
         }
         return response.data;
     }
     async deleteWebhook(walletAddress, webhookId, auth) {
-        const response = await this.delete(`/wallets/${encodeURIComponent(walletAddress)}/webhooks/${encodeURIComponent(webhookId)}`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] deleteWebhook failed:', errorMessage);
-            throw new Error(`Failed to delete webhook: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.delete(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/webhooks/${encodeURIComponent(webhookId)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'delete webhook');
         }
         return response.data;
     }
     async createAuthChallenge(walletIdentifier, clientId, redirectUri, deviceFingerprint) {
-        const response = await this.post('/auth/challenge', {
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, '/auth/challenge'), {
             wallet_identifier: walletIdentifier,
             client_id: clientId,
             redirect_uri: redirectUri,
             device_fingerprint: deviceFingerprint,
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] createAuthChallenge failed:', errorMessage);
-            throw new Error(`Failed to create auth challenge: ${errorMessage}`);
+        }, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'create auth challenge');
         }
         return response.data;
     }
     async verifyAuthSignature(sessionId, signature, chainType, currentWallet) {
-        const response = await this.post('/auth/verify', {
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, '/auth/verify'), {
             session_id: sessionId,
             signature,
             chain_type: chainType,
             current_wallet: currentWallet,
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] verifyAuthSignature failed:', errorMessage);
-            throw new Error(`Failed to verify signature: ${errorMessage}`);
+        }, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'verify signature');
         }
         return response.data;
     }
     async authorizeOAuth(clientId, redirectUri, responseType, scope, state, sessionId, codeChallenge, codeChallengeMethod, nonce, privacy) {
+        const headers = createHeaders(this.dev, { 'X-Session-Id': sessionId });
         const queryParams = new URLSearchParams({
             client_id: clientId,
             redirect_uri: redirectUri,
@@ -435,19 +280,14 @@ export class IndexerClient {
             queryParams.append('nonce', nonce);
         if (privacy)
             queryParams.append('privacy', privacy);
-        const response = await this.get(`/oauth/authorize?${queryParams.toString()}`, {
-            headers: {
-                'X-Session-Id': sessionId,
-            },
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] authorizeOAuth failed:', errorMessage);
-            throw new Error(`Failed to authorize: ${errorMessage}`);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/oauth/authorize?${queryParams.toString()}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'authorize');
         }
         return response.data;
     }
     async exchangeOAuthToken(grantType, clientId, code, redirectUri, clientSecret, codeVerifier, refreshToken) {
+        const headers = createHeaders(this.dev);
         const body = {
             grant_type: grantType,
             client_id: clientId,
@@ -462,112 +302,93 @@ export class IndexerClient {
             body.code_verifier = codeVerifier;
         if (refreshToken)
             body.refresh_token = refreshToken;
-        const response = await this.post('/oauth/token', body);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] exchangeOAuthToken failed:', errorMessage);
-            throw new Error(`Failed to exchange token: ${errorMessage}`);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, '/oauth/token'), body, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'exchange token');
         }
         return response.data;
     }
     async getOAuthUserInfo(accessToken) {
-        const response = await this.get('/oauth/userinfo', {
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-            },
+        const headers = createHeaders(this.dev, {
+            Authorization: `Bearer ${accessToken}`,
         });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getOAuthUserInfo failed:', errorMessage);
-            throw new Error(`Failed to get user info: ${errorMessage}`);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, '/oauth/userinfo'), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get user info');
         }
         return response.data;
     }
     async revokeOAuthToken(token, tokenTypeHint) {
+        const headers = createHeaders(this.dev);
         const body = { token };
         if (tokenTypeHint)
             body.token_type_hint = tokenTypeHint;
-        const response = await this.post('/oauth/revoke', body);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] revokeOAuthToken failed:', errorMessage);
-            throw new Error(`Failed to revoke token: ${errorMessage}`);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, '/oauth/revoke'), body, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'revoke token');
         }
     }
     async getOAuthClientInfo(clientId) {
-        const response = await this.get(`/oauth/clients/${clientId}`);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getOAuthClientInfo failed:', errorMessage);
-            throw new Error(`Failed to get client info: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/oauth/clients/${clientId}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get client info');
         }
         return response.data;
     }
     async initiateKYC(walletAddress, auth, verificationLevel) {
-        const response = await this.post(`/kyc/initiate/${encodeURIComponent(walletAddress)}`, { verificationLevel }, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] initiateKYC failed:', errorMessage);
-            throw new Error(`Failed to initiate KYC: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.post(buildUrl(this.baseUrl, `/kyc/initiate/${encodeURIComponent(walletAddress)}`), { verificationLevel }, { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'initiate KYC');
         }
         return response.data;
     }
     async getKYCStatus(walletAddress, auth) {
-        const response = await this.get(`/kyc/status/${encodeURIComponent(walletAddress)}`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getKYCStatus failed:', errorMessage);
-            throw new Error(`Failed to get KYC status: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/kyc/status/${encodeURIComponent(walletAddress)}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get KYC status');
         }
         return response.data;
     }
     async checkAuthenticated(walletAddress, auth) {
-        const response = await this.get(`/wallets/${encodeURIComponent(walletAddress)}/authenticated`, {
-            headers: this.createAuthHeaders(auth),
-        });
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] checkAuthenticated failed:', errorMessage);
-            throw new Error(`Failed to check authentication status: ${errorMessage}`);
+        const headers = createAuthHeaders(auth, this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/wallets/${encodeURIComponent(walletAddress)}/authenticated`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'check authentication status');
         }
         return response.data;
     }
     async getBlockStatus() {
-        const response = await this.get('/blocks');
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getBlockStatus failed:', errorMessage);
-            throw new Error(`Failed to get block status: ${errorMessage}`);
+        const headers = createHeaders(this.dev);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, '/blocks'), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get block status');
         }
         return response.data;
     }
     async getContractPermissions(contractAddress, chainId, testNet = false) {
+        const headers = createHeaders(this.dev);
         const queryParams = new URLSearchParams({
             chainId: chainId.toString(),
             testNet: testNet.toString(),
         });
-        const response = await this.get(`/permissions/contract/${encodeURIComponent(contractAddress)}?${queryParams.toString()}`);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getContractPermissions failed:', errorMessage);
-            throw new Error(`Failed to get contract permissions: ${errorMessage}`);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/permissions/contract/${encodeURIComponent(contractAddress)}?${queryParams.toString()}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get contract permissions');
         }
         return response.data;
     }
     async getWalletPermissions(walletAddress, chainId, testNet = false) {
+        const headers = createHeaders(this.dev);
         const queryParams = new URLSearchParams({
             chainId: chainId.toString(),
             testNet: testNet.toString(),
         });
-        const response = await this.get(`/permissions/wallet/${encodeURIComponent(walletAddress)}?${queryParams.toString()}`);
-        if (!response.ok) {
-            const errorMessage = response.data?.error || 'Unknown error';
-            console.error('[IndexerClient] getWalletPermissions failed:', errorMessage);
-            throw new Error(`Failed to get wallet permissions: ${errorMessage}`);
+        const response = await this.networkClient.get(buildUrl(this.baseUrl, `/permissions/wallet/${encodeURIComponent(walletAddress)}?${queryParams.toString()}`), { headers });
+        if (!response.ok || !response.data) {
+            throw handleApiError(response, 'get wallet permissions');
         }
         return response.data;
     }