@microcosmmoney/auth-react 1.0.3 → 1.1.0

package/dist/hooks/use-lending-pool.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLendingPool = useLendingPool;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useLendingPool(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/lending/pool',
+        refetchInterval: options?.refetchInterval ?? 120000,
+    });
+}

package/dist/hooks/use-lending-position.d.ts

@@ -0,0 +1,3 @@
+export declare function useLendingPosition(wallet?: string, options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-lending-position.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLendingPosition = useLendingPosition;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useLendingPosition(wallet, options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: `/lending/position/${wallet}`,
+        skip: !wallet,
+        requireAuth: true,
+        refetchInterval: options?.refetchInterval ?? 60000,
+    });
+}

package/dist/hooks/use-lending-stats.d.ts

@@ -0,0 +1,3 @@
+export declare function useLendingStats(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-lending-stats.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLendingStats = useLendingStats;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useLendingStats(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/lending/stats',
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-manager-income.d.ts

@@ -0,0 +1,9 @@
+import type { TerritoryIncome } from '@microcosmmoney/auth-core';
+export interface ManagerIncomeData {
+    total_income: number;
+    pending_income: number;
+    records: TerritoryIncome[];
+}
+export declare function useManagerIncome(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<ManagerIncomeData>;

package/dist/hooks/use-manager-income.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useManagerIncome = useManagerIncome;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useManagerIncome(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/territories/manager/income',
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-market-data.d.ts

@@ -0,0 +1,4 @@
+import type { DashboardMarketSummary } from '@microcosmmoney/auth-core';
+export declare function useMarketData(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<DashboardMarketSummary>;

package/dist/hooks/use-market-data.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarketData = useMarketData;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMarketData(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/dashboard/market',
+        refetchInterval: options?.refetchInterval ?? 120000,
+    });
+}

package/dist/hooks/use-mcc-history.d.ts

@@ -0,0 +1,11 @@
+import type { MCCHistoryRecord, PaginatedResult } from '@microcosmmoney/auth-core';
+export declare function useMCCHistory(params?: {
+    tx_type?: string;
+    page?: number;
+    page_size?: number;
+}): {
+    data: PaginatedResult<MCCHistoryRecord> | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};

package/dist/hooks/use-mcc-history.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCCHistory = useMCCHistory;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMCCHistory(params) {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const p = params || {};
+    const page = p.page || 1;
+    const pageSize = p.page_size || 20;
+    const txType = p.tx_type;
+    const fetchData = (0, react_1.useCallback)(async () => {
+        if (!isAuthenticated) {
+            setData(null);
+            setLoading(false);
+            return;
+        }
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            let qs = `?page=${page}&page_size=${pageSize}`;
+            if (txType)
+                qs += `&tx_type=${txType}`;
+            const res = await api.get(`/mcc/history${qs}`);
+            if (mountedRef.current) {
+                setData(res.data);
+                setError(null);
+            }
+        }
+        catch (err) {
+            if (mountedRef.current)
+                setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client, isAuthenticated, page, pageSize, txType]);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        fetchData();
+        return () => { mountedRef.current = false; };
+    }, [fetchData]);
+    return { data, loading, error, refresh: fetchData };
+}

package/dist/hooks/use-mcc-holders.d.ts

@@ -0,0 +1,3 @@
+export declare function useMCCHolders(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-mcc-holders.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCCHolders = useMCCHolders;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMCCHolders(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/reincarnation/holders',
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-mcc-mining-history.d.ts

@@ -0,0 +1,3 @@
+export declare function useMCCMiningHistory(days?: number, options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any[]>;

package/dist/hooks/use-mcc-mining-history.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCCMiningHistory = useMCCMiningHistory;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMCCMiningHistory(days = 30, options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: `/reincarnation/mining-history?days=${days}`,
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-mcc-stats.d.ts

@@ -1,3 +1,4 @@
+import type { MCCStats } from '@microcosmmoney/auth-core';
 export declare function useMCCStats(options?: {
     refetchInterval?: number;
-}): import("./use-api-query").UseApiQueryResult<any>;
+}): import("./use-api-query").UseApiQueryResult<MCCStats>;

package/dist/hooks/use-mcd.js

@@ -19,7 +19,7 @@ function useMCD(refreshInterval) {
             setLoading(true);
             const api = client.getApiClient();
             const data = await api.get('/mcd/balance');
-            setBalance(data.data?.attributes || null);
+            setBalance(data.data || null);
             setError(null);
         }
         catch (err) {

package/dist/hooks/use-mining-action.d.ts

@@ -0,0 +1,20 @@
+import type { MiningRequestResult } from '@microcosmmoney/auth-core';
+interface MiningRequestParams {
+    mcc_amount: number;
+    stablecoin?: string;
+    wallet_address: string;
+}
+interface MiningConfirmParams {
+    request_id: string;
+    tx_signature: string;
+    mcc_amount: number;
+    usdc_amount: number;
+    stablecoin_type?: string;
+}
+export declare function useMiningAction(): {
+    createRequest: (params: MiningRequestParams) => Promise<MiningRequestResult | null>;
+    confirm: (params: MiningConfirmParams) => Promise<any>;
+    loading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/hooks/use-mining-action.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMiningAction = useMiningAction;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMiningAction() {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const createRequest = (0, react_1.useCallback)(async (params) => {
+        if (!isAuthenticated)
+            throw new Error('Authentication required');
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post('/mining/request', params);
+            return res.data;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            if (mountedRef.current)
+                setError(e);
+            throw e;
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client, isAuthenticated]);
+    const confirm = (0, react_1.useCallback)(async (params) => {
+        if (!isAuthenticated)
+            throw new Error('Authentication required');
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post('/mining/confirm', params);
+            return res.data;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            if (mountedRef.current)
+                setError(e);
+            throw e;
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client, isAuthenticated]);
+    return { createRequest, confirm, loading, error };
+}

package/dist/hooks/use-mining-config.d.ts

@@ -0,0 +1,7 @@
+import type { MiningConfig } from '@microcosmmoney/auth-core';
+export declare function useMiningConfig(): {
+    data: MiningConfig | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};

package/dist/hooks/use-mining-config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMiningConfig = useMiningConfig;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMiningConfig() {
+    const { client } = (0, provider_1.useAuth)();
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const fetchData = (0, react_1.useCallback)(async () => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            const res = await api.get('/mining/config');
+            if (mountedRef.current) {
+                setData(res.data);
+                setError(null);
+            }
+        }
+        catch (err) {
+            if (mountedRef.current)
+                setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client]);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        fetchData();
+        return () => { mountedRef.current = false; };
+    }, [fetchData]);
+    return { data, loading, error, refresh: fetchData };
+}

package/dist/hooks/use-mining-distribution.d.ts

@@ -1,6 +1,6 @@
-import type { MiningDistribution } from '@microcosmmoney/auth-core';
+import type { MiningDistribution, PaginatedResult } from '@microcosmmoney/auth-core';
 export declare function useMiningDistribution(options?: {
     page?: number;
     pageSize?: number;
     refetchInterval?: number;
-}): import("./use-api-query").UseApiQueryResult<MiningDistribution[]>;
+}): import("./use-api-query").UseApiQueryResult<PaginatedResult<MiningDistribution>>;

package/dist/hooks/use-mining-flow.d.ts

@@ -0,0 +1,22 @@
+export type MiningFlowStep = 'idle' | 'requesting' | 'confirming' | 'signing' | 'completed' | 'error';
+export interface MiningFlowState {
+    step: MiningFlowStep;
+    requestData: any | null;
+    confirmData: any | null;
+    txSignature: string | null;
+    error: string | null;
+}
+export declare function useMiningFlow(): {
+    startMining: (params: {
+        amount: number;
+        wallet_address: string;
+        stablecoin?: "USDT" | "USDC";
+    }) => Promise<any>;
+    confirmMining: (requestId: string, txSignature: string) => Promise<any>;
+    reset: () => void;
+    step: MiningFlowStep;
+    requestData: any | null;
+    confirmData: any | null;
+    txSignature: string | null;
+    error: string | null;
+};

package/dist/hooks/use-mining-flow.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMiningFlow = useMiningFlow;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMiningFlow() {
+    const { client } = (0, provider_1.useAuth)();
+    const [state, setState] = (0, react_1.useState)({
+        step: 'idle',
+        requestData: null,
+        confirmData: null,
+        txSignature: null,
+        error: null,
+    });
+    const reset = (0, react_1.useCallback)(() => {
+        setState({ step: 'idle', requestData: null, confirmData: null, txSignature: null, error: null });
+    }, []);
+    const startMining = (0, react_1.useCallback)(async (params) => {
+        const api = client.getApiClient();
+        setState(s => ({ ...s, step: 'requesting', error: null }));
+        try {
+            const req = await api.post('/mcc/mining/request', params);
+            setState(s => ({ ...s, step: 'confirming', requestData: req.data }));
+            return req.data;
+        }
+        catch (e) {
+            setState(s => ({ ...s, step: 'error', error: e.message }));
+            throw e;
+        }
+    }, [client]);
+    const confirmMining = (0, react_1.useCallback)(async (requestId, txSignature) => {
+        const api = client.getApiClient();
+        setState(s => ({ ...s, step: 'signing' }));
+        try {
+            const res = await api.post('/mcc/mining/confirm', { request_id: requestId, tx_signature: txSignature });
+            setState(s => ({ ...s, step: 'completed', confirmData: res.data, txSignature }));
+            return res.data;
+        }
+        catch (e) {
+            setState(s => ({ ...s, step: 'error', error: e.message }));
+            throw e;
+        }
+    }, [client]);
+    return { ...state, startMining, confirmMining, reset };
+}

package/dist/hooks/use-mining-history.d.ts

@@ -0,0 +1,10 @@
+import type { MiningHistoryItem, PaginatedResult } from '@microcosmmoney/auth-core';
+export declare function useMiningHistory(params?: {
+    limit?: number;
+    offset?: number;
+}): {
+    data: PaginatedResult<MiningHistoryItem> | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};

package/dist/hooks/use-mining-history.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMiningHistory = useMiningHistory;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMiningHistory(params) {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const p = params || {};
+    const limit = p.limit || 20;
+    const offset = p.offset || 0;
+    const fetchData = (0, react_1.useCallback)(async () => {
+        if (!isAuthenticated) {
+            setData(null);
+            setLoading(false);
+            return;
+        }
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            const res = await api.get(`/mining/history?limit=${limit}&offset=${offset}`);
+            if (mountedRef.current) {
+                setData(res.data);
+                setError(null);
+            }
+        }
+        catch (err) {
+            if (mountedRef.current)
+                setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client, isAuthenticated, limit, offset]);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        fetchData();
+        return () => { mountedRef.current = false; };
+    }, [fetchData]);
+    return { data, loading, error, refresh: fetchData };
+}

package/dist/hooks/use-mining-records.d.ts

@@ -1,4 +1,5 @@
+import type { MiningRecord, PaginatedResult } from '@microcosmmoney/auth-core';
 export declare function useMiningRecords(options?: {
     limit?: number;
     refetchInterval?: number;
-}): import("./use-api-query").UseApiQueryResult<any>;
+}): import("./use-api-query").UseApiQueryResult<PaginatedResult<MiningRecord>>;

package/dist/hooks/use-mining-stats.d.ts

@@ -1,3 +1,4 @@
+import type { MiningStats } from '@microcosmmoney/auth-core';
 export declare function useMiningStats(options?: {
     refetchInterval?: number;
-}): import("./use-api-query").UseApiQueryResult<any>;
+}): import("./use-api-query").UseApiQueryResult<MiningStats>;

package/dist/hooks/use-multi-wallet-balance.d.ts

@@ -0,0 +1,15 @@
+import type { TokenPortfolio } from '@microcosmmoney/auth-core';
+interface WalletBalance {
+    wallet_address: string;
+    is_primary: boolean;
+    portfolio: TokenPortfolio;
+}
+export declare function useMultiWalletBalance(options?: {
+    refetchInterval?: number;
+}): {
+    data: WalletBalance[] | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+export {};

package/dist/hooks/use-multi-wallet-balance.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiWalletBalance = useMultiWalletBalance;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMultiWalletBalance(options) {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const fetchData = (0, react_1.useCallback)(async () => {
+        if (!isAuthenticated) {
+            setData(null);
+            setLoading(false);
+            return;
+        }
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            const walletsRes = await api.get('/wallets');
+            const wallets = walletsRes.data?.wallets || [];
+            const balances = await Promise.all(wallets.map(async (w) => {
+                const balRes = await api.get(`/wallets/${w.wallet_address}/tokens`).catch(() => ({ data: {} }));
+                return { wallet_address: w.wallet_address, is_primary: w.is_primary, portfolio: balRes.data };
+            }));
+            if (mountedRef.current) {
+                setData(balances);
+                setError(null);
+            }
+        }
+        catch (err) {
+            if (mountedRef.current)
+                setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client, isAuthenticated]);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        fetchData();
+        const interval = options?.refetchInterval ?? 120000;
+        if (interval > 0) {
+            const timer = setInterval(fetchData, interval);
+            return () => { mountedRef.current = false; clearInterval(timer); };
+        }
+        return () => { mountedRef.current = false; };
+    }, [fetchData, options?.refetchInterval]);
+    return { data, loading, error, refresh: fetchData };
+}

package/dist/hooks/use-notification-action.d.ts

@@ -0,0 +1,10 @@
+export declare function useNotificationAction(): {
+    markRead: (notificationId: string) => Promise<{
+        success: boolean;
+    }>;
+    markAllRead: () => Promise<{
+        success: boolean;
+    }>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/use-notification-action.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNotificationAction = useNotificationAction;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useNotificationAction() {
+    const { client } = (0, provider_1.useAuth)();
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const markRead = (0, react_1.useCallback)(async (notificationId) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            return await api.post(`/notifications/${notificationId}/read`, {});
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            if (mountedRef.current)
+                setError(e);
+            throw e;
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client]);
+    const markAllRead = (0, react_1.useCallback)(async () => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            return await api.post('/notifications/read-all', {});
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            if (mountedRef.current)
+                setError(e);
+            throw e;
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client]);
+    return { markRead, markAllRead, loading, error };
+}

package/dist/hooks/use-notifications.d.ts

@@ -0,0 +1,13 @@
+export interface Notification {
+    id: string;
+    type: string;
+    title: string;
+    message: string;
+    read: boolean;
+    created_at: string;
+    data?: Record<string, any>;
+}
+export declare function useNotifications(options?: {
+    refetchInterval?: number;
+    unreadOnly?: boolean;
+}): import("./use-api-query").UseApiQueryResult<Notification[]>;

package/dist/hooks/use-notifications.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNotifications = useNotifications;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useNotifications(options) {
+    const params = new URLSearchParams();
+    if (options?.unreadOnly)
+        params.set('unread', 'true');
+    const qs = params.toString();
+    return (0, use_api_query_1.useApiQuery)({
+        path: `/notifications${qs ? `?${qs}` : ''}`,
+        refetchInterval: options?.refetchInterval ?? 30000,
+    });
+}