@abstraxn/signer-react 3.3.2 → 3.3.3

package/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.3] - 2026-07-09
+
+### Changed
+- Bumped `@abstraxn/signer-core` to `2.1.3` for automatic secure-enclave policy
+  stamp/confirm on publish, unpublish, update, and delete (enforced policies).
+
 ## [3.3.0] - 2026-04-28
 
 ### Added

package/dist/src/components/AbstraxnProvider/AbstraxnProviderInner.js

@@ -2406,6 +2406,54 @@ export function AbstraxnProviderInner({ config, children, base, wagmi, solana, }
         }
         await walletRef.current.linkEmail(otpId, otpCode);
     }, []);
+    const createPolicy = useCallback(async (input) => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        return await walletRef.current.createPolicy(input);
+    }, []);
+    const listPolicies = useCallback(async (filters) => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        return await walletRef.current.listPolicies(filters);
+    }, []);
+    const getPolicy = useCallback(async (policyId) => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        return await walletRef.current.getPolicy(policyId);
+    }, []);
+    const updatePolicy = useCallback(async (policyId, input) => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        return await walletRef.current.updatePolicy(policyId, input);
+    }, []);
+    const deletePolicy = useCallback(async (policyId) => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        await walletRef.current.deletePolicy(policyId);
+    }, []);
+    const publishPolicy = useCallback(async (policyId) => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        return await walletRef.current.publishPolicy(policyId);
+    }, []);
+    const unpublishPolicy = useCallback(async (policyId) => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        return await walletRef.current.unpublishPolicy(policyId);
+    }, []);
+    const getPolicyTemplates = useCallback(async () => {
+        if (!walletRef.current?.isConnected) {
+            throw new Error("Wallet not connected");
+        }
+        return await walletRef.current.getPolicyTemplates();
+    }, []);
     // MFA helpers (delegating to core wallet/AuthManager)
     const getMfaStatus = useCallback(async () => {
         if (!walletRef.current?.isConnected) {
@@ -3639,6 +3687,14 @@ export function AbstraxnProviderInner({ config, children, base, wagmi, solana, }
         requestOtpForEmailLink,
         linkEmail,
         unlinkAuthMethod,
+        createPolicy,
+        listPolicies,
+        getPolicy,
+        updatePolicy,
+        deletePolicy,
+        publishPolicy,
+        unpublishPolicy,
+        getPolicyTemplates,
         uiConfig: enrichedUiConfig,
         // External wallet methods
         connectExternalWallet: externalWalletsEnabled

package/dist/src/hooks.d.ts

@@ -13495,3 +13495,57 @@ export declare function useSolanaExternalWallet(): {
     signAllTransactions: (transactions: SolanaTransaction[]) => Promise<SolanaTransaction[]>;
     sendTransaction: (transaction: SolanaTransaction, options?: SendOptions) => Promise<string>;
 };
+/**
+ * List wallet policies for the connected org. Optionally filter by walletId/status/blockchain.
+ */
+export declare function usePolicies(filters?: import("@abstraxn/signer-core").PolicyListFilters): {
+    policies: import("@abstraxn/signer-core").WalletPolicy[];
+    total: number;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<import("@abstraxn/signer-core").WalletPolicyListResponse | null>;
+    isConnected: boolean;
+};
+/**
+ * Fetch a single policy by id.
+ */
+export declare function usePolicy(policyId: string | null | undefined): {
+    policy: import("@abstraxn/signer-core").WalletPolicy | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<import("@abstraxn/signer-core").WalletPolicy | null>;
+    isConnected: boolean;
+};
+export declare function useCreatePolicy(): {
+    createPolicy: (input: import("@abstraxn/signer-core").CreatePolicyInput) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    isLoading: boolean;
+    error: string | null;
+};
+export declare function useUpdatePolicy(): {
+    updatePolicy: (policyId: string, input: import("@abstraxn/signer-core").UpdatePolicyInput) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    isLoading: boolean;
+    error: string | null;
+};
+export declare function useDeletePolicy(): {
+    deletePolicy: (policyId: string) => Promise<void>;
+    isLoading: boolean;
+    error: string | null;
+};
+export declare function usePublishPolicy(): {
+    publishPolicy: (policyId: string) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    isLoading: boolean;
+    error: string | null;
+};
+export declare function useUnpublishPolicy(): {
+    unpublishPolicy: (policyId: string) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    isLoading: boolean;
+    error: string | null;
+};
+export declare function usePolicyTemplates(): {
+    templates: import("@abstraxn/signer-core").PolicyTemplateInfo[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<{
+        templates: import("@abstraxn/signer-core").PolicyTemplateInfo[];
+    } | null>;
+};

package/dist/src/hooks.js

@@ -2712,4 +2712,227 @@ export function useSolanaExternalWallet() {
         sendTransaction,
     };
 }
+// ─── Wallet Policies ─────────────────────────────────────────────────────────
+/**
+ * List wallet policies for the connected org. Optionally filter by walletId/status/blockchain.
+ */
+export function usePolicies(filters) {
+    const { isConnected, listPolicies } = useAbstraxnWallet();
+    const [policies, setPolicies] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async () => {
+        if (!isConnected || !listPolicies) {
+            setError(new Error("Wallet is not connected"));
+            return null;
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await listPolicies(filters);
+            setPolicies(result.policies);
+            setTotal(result.total);
+            return result;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error("Failed to list policies");
+            setError(e);
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [isConnected, listPolicies, filters?.walletId, filters?.status, filters?.blockchain, filters?.enabled]);
+    useEffect(() => {
+        if (isConnected && listPolicies) {
+            void refresh();
+        }
+    }, [isConnected]); // eslint-disable-line react-hooks/exhaustive-deps
+    return { policies, total, loading, error, refresh, isConnected };
+}
+/**
+ * Fetch a single policy by id.
+ */
+export function usePolicy(policyId) {
+    const { isConnected, getPolicy } = useAbstraxnWallet();
+    const [policy, setPolicy] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async () => {
+        if (!policyId)
+            return null;
+        if (!isConnected || !getPolicy) {
+            setError(new Error("Wallet is not connected"));
+            return null;
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await getPolicy(policyId);
+            setPolicy(result);
+            return result;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error("Failed to get policy");
+            setError(e);
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [isConnected, getPolicy, policyId]);
+    useEffect(() => {
+        if (isConnected && policyId && getPolicy) {
+            void refresh();
+        }
+    }, [isConnected, policyId]); // eslint-disable-line react-hooks/exhaustive-deps
+    return { policy, loading, error, refresh, isConnected };
+}
+export function useCreatePolicy() {
+    const { createPolicy: createPolicyFn } = useAbstraxnWallet();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const createPolicy = useCallback(async (input) => {
+        if (!createPolicyFn)
+            throw new Error("createPolicy is not available");
+        setIsLoading(true);
+        setError(null);
+        try {
+            return await createPolicyFn(input);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to create policy";
+            setError(msg);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [createPolicyFn]);
+    return { createPolicy, isLoading, error };
+}
+export function useUpdatePolicy() {
+    const { updatePolicy: updatePolicyFn } = useAbstraxnWallet();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const updatePolicy = useCallback(async (policyId, input) => {
+        if (!updatePolicyFn)
+            throw new Error("updatePolicy is not available");
+        setIsLoading(true);
+        setError(null);
+        try {
+            return await updatePolicyFn(policyId, input);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to update policy";
+            setError(msg);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [updatePolicyFn]);
+    return { updatePolicy, isLoading, error };
+}
+export function useDeletePolicy() {
+    const { deletePolicy: deletePolicyFn } = useAbstraxnWallet();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const deletePolicy = useCallback(async (policyId) => {
+        if (!deletePolicyFn)
+            throw new Error("deletePolicy is not available");
+        setIsLoading(true);
+        setError(null);
+        try {
+            await deletePolicyFn(policyId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to delete policy";
+            setError(msg);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [deletePolicyFn]);
+    return { deletePolicy, isLoading, error };
+}
+export function usePublishPolicy() {
+    const { publishPolicy: publishPolicyFn } = useAbstraxnWallet();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const publishPolicy = useCallback(async (policyId) => {
+        if (!publishPolicyFn)
+            throw new Error("publishPolicy is not available");
+        setIsLoading(true);
+        setError(null);
+        try {
+            return await publishPolicyFn(policyId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to publish policy";
+            setError(msg);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [publishPolicyFn]);
+    return { publishPolicy, isLoading, error };
+}
+export function useUnpublishPolicy() {
+    const { unpublishPolicy: unpublishPolicyFn } = useAbstraxnWallet();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const unpublishPolicy = useCallback(async (policyId) => {
+        if (!unpublishPolicyFn)
+            throw new Error("unpublishPolicy is not available");
+        setIsLoading(true);
+        setError(null);
+        try {
+            return await unpublishPolicyFn(policyId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to unpublish policy";
+            setError(msg);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [unpublishPolicyFn]);
+    return { unpublishPolicy, isLoading, error };
+}
+export function usePolicyTemplates() {
+    const { isConnected, getPolicyTemplates } = useAbstraxnWallet();
+    const [templates, setTemplates] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async () => {
+        if (!isConnected || !getPolicyTemplates)
+            return null;
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await getPolicyTemplates();
+            setTemplates(result.templates);
+            return result;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error("Failed to load templates");
+            setError(e);
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [isConnected, getPolicyTemplates]);
+    useEffect(() => {
+        if (isConnected && getPolicyTemplates) {
+            void refresh();
+        }
+    }, [isConnected]); // eslint-disable-line react-hooks/exhaustive-deps
+    return { templates, loading, error, refresh };
+}
 //# sourceMappingURL=hooks.js.map

package/dist/src/index.d.ts

@@ -4,7 +4,7 @@
  * when used in a React project
  */
 export { AbstraxnProvider, useAbstraxnWallet } from './AbstraxnProvider';
-export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, } from './hooks';
+export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, usePolicies, usePolicy, useCreatePolicy, useUpdatePolicy, useDeletePolicy, usePublishPolicy, useUnpublishPolicy, usePolicyTemplates, } from './hooks';
 export { ConnectButton } from './ConnectButton';
 export type { ConnectButtonProps, ConnectButtonVariant, ConnectButtonSize } from './ConnectButton';
 export { WalletModal } from './WalletModal';

package/dist/src/index.js

@@ -4,7 +4,7 @@
  * when used in a React project
  */
 export { AbstraxnProvider, useAbstraxnWallet } from './AbstraxnProvider';
-export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, } from './hooks';
+export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, usePolicies, usePolicy, useCreatePolicy, useUpdatePolicy, useDeletePolicy, usePublishPolicy, useUnpublishPolicy, usePolicyTemplates, } from './hooks';
 export { ConnectButton } from './ConnectButton';
 export { WalletModal } from './WalletModal';
 export { OnboardingUIComponent as OnboardingUI } from './OnboardingUI';

package/dist/src/types.d.ts

@@ -281,6 +281,16 @@ export interface AbstraxnContextValue {
     }>;
     linkEmail?: (otpId: string, otpCode: string) => Promise<void>;
     unlinkAuthMethod?: (provider: string) => Promise<void>;
+    createPolicy?: (input: import("@abstraxn/signer-core").CreatePolicyInput) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    listPolicies?: (filters?: import("@abstraxn/signer-core").PolicyListFilters) => Promise<import("@abstraxn/signer-core").WalletPolicyListResponse>;
+    getPolicy?: (policyId: string) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    updatePolicy?: (policyId: string, input: import("@abstraxn/signer-core").UpdatePolicyInput) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    deletePolicy?: (policyId: string) => Promise<void>;
+    publishPolicy?: (policyId: string) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    unpublishPolicy?: (policyId: string) => Promise<import("@abstraxn/signer-core").WalletPolicy>;
+    getPolicyTemplates?: () => Promise<{
+        templates: import("@abstraxn/signer-core").PolicyTemplateInfo[];
+    }>;
     connectExternalWallet?: (connectorId: string) => Promise<void>;
     disconnectExternalWallet?: () => Promise<void>;
     isExternalWalletConnected?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abstraxn/signer-react",
-  "version": "3.3.2",
+  "version": "3.3.3",
   "description": "React SDK for Abstraxn Wallet - React components, hooks, and providers for seamless Web3 wallet integration",
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@abstraxn/signer-core": "2.1.2",
+    "@abstraxn/signer-core": "2.1.3",
     "@abstraxn/solana-relayer": "^1.1.0",
     "@solana/wallet-adapter-base": "^0.9.27",
     "@solana/wallet-adapter-react": "^0.15.39",