@microcosmmoney/auth-react 1.0.3 → 1.1.0

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-public-mining.d.ts

@@ -0,0 +1,12 @@
+interface PublicMiningRequestParams {
+    wallet_address: string;
+    mcc_amount: number;
+    stablecoin?: string;
+}
+export declare function usePublicMining(): {
+    createRequest: (params: PublicMiningRequestParams) => Promise<any>;
+    verify: (requestId: string, txSignature: string) => Promise<any>;
+    loading: boolean;
+    error: Error | null;
+};
+export {};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePublicMining = usePublicMining;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function usePublicMining() {
+    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 createRequest = (0, react_1.useCallback)(async (params) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post('/mining/public/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]);
+    const verify = (0, react_1.useCallback)(async (requestId, txSignature) => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            setError(null);
+            const res = await api.post('/mining/public/verify', {
+                request_id: requestId,
+                tx_signature: txSignature,
+            });
+            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 { createRequest, verify, loading, error };
+}

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReincarnationConfig = useReincarnationConfig;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useReincarnationConfig() {
+    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('/reincarnation/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-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[]>;

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

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

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

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

package/dist/hooks/use-territory-detailed-stats.d.ts

@@ -0,0 +1,9 @@
+import type { TerritoryStats, TerritoryKPI, TechTreeBonus } from '@microcosmmoney/auth-core';
+export interface TerritoryDetailedStats {
+    stats: TerritoryStats;
+    kpi?: TerritoryKPI;
+    tech_bonus?: TechTreeBonus;
+}
+export declare function useTerritoryDetailedStats(territoryId: string, options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<TerritoryDetailedStats>;

package/dist/hooks/use-territory-detailed-stats.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTerritoryDetailedStats = useTerritoryDetailedStats;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useTerritoryDetailedStats(territoryId, options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: `/territories/${territoryId}/detailed-stats`,
+        refetchInterval: options?.refetchInterval ?? 60000,
+        skip: !territoryId,
+    });
+}

package/dist/hooks/use-territory-distribution-plan.d.ts

@@ -0,0 +1,16 @@
+interface DistributionPlan {
+    territory_id: string;
+    distribution_type: string;
+    parameters: Record<string, any>;
+    updated_at: string;
+}
+export declare function useTerritoryDistributionPlan(territoryId?: string): {
+    updatePlan: (plan: Partial<DistributionPlan>) => Promise<DistributionPlan | undefined>;
+    updating: boolean;
+    updateError: Error | null;
+    data: DistributionPlan | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+export {};

package/dist/hooks/use-territory-distribution-plan.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTerritoryDistributionPlan = useTerritoryDistributionPlan;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+const use_api_query_1 = require("./use-api-query");
+function useTerritoryDistributionPlan(territoryId) {
+    const { client } = (0, provider_1.useAuth)();
+    const [updating, setUpdating] = (0, react_1.useState)(false);
+    const [updateError, setUpdateError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const query = (0, use_api_query_1.useApiQuery)({
+        path: `/territories/${territoryId}/distribution-plan`,
+        skip: !territoryId,
+        requireAuth: true,
+    });
+    const updatePlan = (0, react_1.useCallback)(async (plan) => {
+        if (!territoryId)
+            return;
+        const api = client.getApiClient();
+        try {
+            setUpdating(true);
+            setUpdateError(null);
+            const res = await api.put(`/territories/${territoryId}/distribution-plan`, plan);
+            query.refresh();
+            return res.data;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            if (mountedRef.current)
+                setUpdateError(e);
+            throw e;
+        }
+        finally {
+            if (mountedRef.current)
+                setUpdating(false);
+        }
+    }, [client, territoryId, query]);
+    return { ...query, updatePlan, updating, updateError };
+}

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

@@ -0,0 +1,6 @@
+export declare function useTerritoryIncome(territoryId?: string, period?: string): {
+    data: any;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};