@microcosmmoney/auth-react 1.0.4 → 1.1.0

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

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

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,
+    });
+}

package/dist/hooks/use-organization-summary.d.ts

@@ -0,0 +1,12 @@
+interface OrganizationSummary {
+    total_stations: number;
+    total_matrices: number;
+    total_sectors: number;
+    total_systems: number;
+    total_members: number;
+    total_vault_mcd: number;
+}
+export declare function useOrganizationSummary(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<OrganizationSummary>;
+export {};

package/dist/hooks/use-organization-summary.js

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

package/dist/hooks/use-organization-tree.d.ts

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

package/dist/hooks/use-organization-tree.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOrganizationTree = useOrganizationTree;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useOrganizationTree(rootId, options) {
+    const path = rootId ? `/organizations/tree?root_id=${rootId}` : '/organizations/tree';
+    return (0, use_api_query_1.useApiQuery)({
+        path,
+        requireAuth: true,
+        refetchInterval: options?.refetchInterval ?? 120000,
+    });
+}

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

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

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

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

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

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

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

@@ -1,5 +1,6 @@
+import type { PriceHistoryPoint } from '@microcosmmoney/auth-core';
 type TimeRange = '1D' | '7D' | '30D';
 export declare function usePriceHistory(range?: TimeRange, options?: {
     refetchInterval?: number;
-}): import("./use-api-query").UseApiQueryResult<any>;
+}): import("./use-api-query").UseApiQueryResult<PriceHistoryPoint[]>;
 export {};

package/dist/hooks/use-proposal-settle.d.ts

@@ -0,0 +1,5 @@
+export declare function useProposalSettle(): {
+    settle: (proposalId: string | number) => Promise<any>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/use-proposal-settle.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProposalSettle = useProposalSettle;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useProposalSettle() {
+    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 settle = (0, react_1.useCallback)(async (proposalId) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post(`/proposals/${proposalId}/settle`, {});
+            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]);
+    return { settle, loading, error };
+}

package/dist/hooks/use-solana-wallet.d.ts

@@ -0,0 +1,16 @@
+export interface SolanaWalletState {
+    connected: boolean;
+    publicKey: string | null;
+    connecting: boolean;
+    error: string | null;
+}
+export declare function useSolanaWallet(): {
+    connect: () => Promise<any>;
+    disconnect: () => Promise<void>;
+    signTransaction: (transaction: any) => Promise<any>;
+    signAllTransactions: (transactions: any[]) => Promise<any>;
+    connected: boolean;
+    publicKey: string | null;
+    connecting: boolean;
+    error: string | null;
+};

package/dist/hooks/use-solana-wallet.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSolanaWallet = useSolanaWallet;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+function useSolanaWallet() {
+    const [state, setState] = (0, react_1.useState)({
+        connected: false,
+        publicKey: null,
+        connecting: false,
+        error: null,
+    });
+    (0, react_1.useEffect)(() => {
+        const sol = window.solana;
+        if (sol?.isPhantom && sol.isConnected && sol.publicKey) {
+            setState({ connected: true, publicKey: sol.publicKey.toString(), connecting: false, error: null });
+        }
+    }, []);
+    const connect = (0, react_1.useCallback)(async () => {
+        const sol = window.solana;
+        if (!sol?.isPhantom) {
+            setState(s => ({ ...s, error: 'Phantom wallet not found' }));
+            return null;
+        }
+        setState(s => ({ ...s, connecting: true, error: null }));
+        try {
+            const resp = await sol.connect();
+            const pk = resp.publicKey.toString();
+            setState({ connected: true, publicKey: pk, connecting: false, error: null });
+            return pk;
+        }
+        catch (e) {
+            setState(s => ({ ...s, connecting: false, error: e.message }));
+            return null;
+        }
+    }, []);
+    const disconnect = (0, react_1.useCallback)(async () => {
+        const sol = window.solana;
+        if (sol)
+            await sol.disconnect();
+        setState({ connected: false, publicKey: null, connecting: false, error: null });
+    }, []);
+    const signTransaction = (0, react_1.useCallback)(async (transaction) => {
+        const sol = window.solana;
+        if (!sol)
+            throw new Error('Wallet not available');
+        return sol.signTransaction(transaction);
+    }, []);
+    const signAllTransactions = (0, react_1.useCallback)(async (transactions) => {
+        const sol = window.solana;
+        if (!sol)
+            throw new Error('Wallet not available');
+        return sol.signAllTransactions(transactions);
+    }, []);
+    return { ...state, connect, disconnect, signTransaction, signAllTransactions };
+}

package/dist/hooks/use-station-join.d.ts

@@ -0,0 +1,5 @@
+export declare function useStationJoin(): {
+    joinStation: (stationId: string) => Promise<any>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/use-station-join.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStationJoin = useStationJoin;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useStationJoin() {
+    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 joinStation = (0, react_1.useCallback)(async (stationId) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post(`/territories/${stationId}/join`, {});
+            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]);
+    return { joinStation, loading, error };
+}

package/dist/hooks/use-station-leave.d.ts

@@ -0,0 +1,5 @@
+export declare function useStationLeave(): {
+    leaveStation: (stationId: string) => Promise<any>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/use-station-leave.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStationLeave = useStationLeave;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useStationLeave() {
+    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 leaveStation = (0, react_1.useCallback)(async (stationId) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post(`/territories/${stationId}/leave`, {});
+            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]);
+    return { leaveStation, loading, error };
+}

package/dist/hooks/use-station-queue.d.ts

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

package/dist/hooks/use-station-queue.js

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

package/dist/hooks/use-team-custody.d.ts

@@ -0,0 +1,18 @@
+export interface CustodyWallet {
+    wallet_address: string;
+    role: string;
+    territory_id?: string;
+    sol_balance: number;
+    mcc_balance: number;
+    mcd_balance: number;
+    usdt_balance: number;
+}
+export interface TeamCustodyData {
+    wallets: CustodyWallet[];
+    total_mcc: number;
+    total_mcd: number;
+    total_usdt: number;
+}
+export declare function useTeamCustody(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<TeamCustodyData>;

package/dist/hooks/use-team-custody.js

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

package/dist/hooks/use-tech-tree-action.d.ts

@@ -0,0 +1,6 @@
+export declare function useTechTreeAction(): {
+    unlock: (nodeId: string) => Promise<any>;
+    upgrade: (nodeId: string) => Promise<any>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/use-tech-tree-action.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTechTreeAction = useTechTreeAction;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useTechTreeAction() {
+    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 unlock = (0, react_1.useCallback)(async (nodeId) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post('/tech-tree/unlock', { node_id: nodeId });
+            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]);
+    const upgrade = (0, react_1.useCallback)(async (nodeId) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post('/tech-tree/upgrade', { node_id: nodeId });
+            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]);
+    return { unlock, upgrade, loading, error };
+}

package/dist/hooks/use-tech-tree-bonus.d.ts

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

package/dist/hooks/use-tech-tree-bonus.js

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

package/dist/hooks/use-tech-tree-config.d.ts

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