@mycelium-ip/react 0.1.0-alpha.0 → 0.1.0-alpha.2

package/dist/hooks/derivative/useCreateDerivativeLink.d.ts

@@ -26,5 +26,77 @@ import { type TransactionResult } from "../../utils/transaction";
  * }
  * ```
  */
-export declare function useCreateDerivativeLink(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+export declare function useCreateDerivativeLink(): {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: CreateDerivativeLinkParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    error: Error;
+    variables: CreateDerivativeLinkParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: TransactionResult;
+    error: null;
+    variables: CreateDerivativeLinkParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+};
 //# sourceMappingURL=useCreateDerivativeLink.d.ts.map

package/dist/hooks/derivative/useCreateDerivativeLink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCreateDerivativeLink.d.ts","sourceRoot":"","sources":["../../../src/hooks/derivative/useCreateDerivativeLink.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB,qHActC"}
+{"version":3,"file":"useCreateDerivativeLink.d.ts","sourceRoot":"","sources":["../../../src/hooks/derivative/useCreateDerivativeLink.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BtC"}

package/dist/hooks/derivative/useCreateDerivativeLink.js

@@ -32,8 +32,12 @@ import { queryKeys } from "../queries/queryKeys";
 export function useCreateDerivativeLink() {
     const { client, connection, wallet, confirmation } = useMyceliumContext();
     const queryClient = useQueryClient();
-    return useMutation({
+    const isWalletConnected = wallet !== null && wallet.publicKey !== null;
+    return Object.assign(Object.assign({}, useMutation({
         mutationFn: async (params) => {
+            if (!client || !wallet) {
+                throw new Error("Wallet not connected");
+            }
             const instruction = await client.ipCore.derivative.createIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
@@ -41,5 +45,5 @@ export function useCreateDerivativeLink() {
             queryClient.invalidateQueries({ queryKey: queryKeys.derivatives() });
             queryClient.invalidateQueries({ queryKey: queryKeys.ips() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/derivative/useUpdateDerivativeLicense.d.ts

@@ -26,5 +26,77 @@ import { type TransactionResult } from "../../utils/transaction";
  * }
  * ```
  */
-export declare function useUpdateDerivativeLicense(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+export declare function useUpdateDerivativeLicense(): {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: UpdateDerivativeLicenseParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    error: Error;
+    variables: UpdateDerivativeLicenseParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: TransactionResult;
+    error: null;
+    variables: UpdateDerivativeLicenseParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+};
 //# sourceMappingURL=useUpdateDerivativeLicense.d.ts.map

package/dist/hooks/derivative/useUpdateDerivativeLicense.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUpdateDerivativeLicense.d.ts","sourceRoot":"","sources":["../../../src/hooks/derivative/useUpdateDerivativeLicense.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAE3E,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,wHAczC"}
+{"version":3,"file":"useUpdateDerivativeLicense.d.ts","sourceRoot":"","sources":["../../../src/hooks/derivative/useUpdateDerivativeLicense.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAE3E,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BzC"}

package/dist/hooks/derivative/useUpdateDerivativeLicense.js

@@ -32,13 +32,17 @@ import { queryKeys } from "../queries/queryKeys";
 export function useUpdateDerivativeLicense() {
     const { client, connection, wallet, confirmation } = useMyceliumContext();
     const queryClient = useQueryClient();
-    return useMutation({
+    const isWalletConnected = wallet !== null && wallet.publicKey !== null;
+    return Object.assign(Object.assign({}, useMutation({
         mutationFn: async (params) => {
+            if (!client || !wallet) {
+                throw new Error("Wallet not connected");
+            }
             const instruction = await client.ipCore.derivative.updateLicenseIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: queryKeys.derivatives() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/entity/useCreateEntity.d.ts

@@ -24,5 +24,77 @@ import { type TransactionResult } from "../../utils/transaction";
  * }
  * ```
  */
-export declare function useCreateEntity(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateEntityParams, unknown>;
+export declare function useCreateEntity(): {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: CreateEntityParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    error: Error;
+    variables: CreateEntityParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: TransactionResult;
+    error: null;
+    variables: CreateEntityParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateEntityParams, unknown>;
+};
 //# sourceMappingURL=useCreateEntity.d.ts.map

package/dist/hooks/entity/useCreateEntity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCreateEntity.d.ts","sourceRoot":"","sources":["../../../src/hooks/entity/useCreateEntity.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,6GAa9B"}
+{"version":3,"file":"useCreateEntity.d.ts","sourceRoot":"","sources":["../../../src/hooks/entity/useCreateEntity.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB9B"}

package/dist/hooks/entity/useCreateEntity.js

@@ -30,13 +30,17 @@ import { queryKeys } from "../queries/queryKeys";
 export function useCreateEntity() {
     const { client, connection, wallet, confirmation } = useMyceliumContext();
     const queryClient = useQueryClient();
-    return useMutation({
+    const isWalletConnected = wallet !== null && wallet.publicKey !== null;
+    return Object.assign(Object.assign({}, useMutation({
         mutationFn: async (params) => {
+            if (!client || !wallet) {
+                throw new Error("Wallet not connected");
+            }
             const instruction = await client.ipCore.entity.createIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: queryKeys.entities() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/entity/useUpdateEntityControllers.d.ts

@@ -24,5 +24,77 @@ import { type TransactionResult } from "../../utils/transaction";
  * }
  * ```
  */
-export declare function useUpdateEntityControllers(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+export declare function useUpdateEntityControllers(): {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: UpdateEntityControllersParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    error: Error;
+    variables: UpdateEntityControllersParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: TransactionResult;
+    error: null;
+    variables: UpdateEntityControllersParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+};
 //# sourceMappingURL=useUpdateEntityControllers.d.ts.map

package/dist/hooks/entity/useUpdateEntityControllers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUpdateEntityControllers.d.ts","sourceRoot":"","sources":["../../../src/hooks/entity/useUpdateEntityControllers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAE3E,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,0BAA0B,wHAczC"}
+{"version":3,"file":"useUpdateEntityControllers.d.ts","sourceRoot":"","sources":["../../../src/hooks/entity/useUpdateEntityControllers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAE3E,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BzC"}

package/dist/hooks/entity/useUpdateEntityControllers.js

@@ -30,13 +30,17 @@ import { queryKeys } from "../queries/queryKeys";
 export function useUpdateEntityControllers() {
     const { client, connection, wallet, confirmation } = useMyceliumContext();
     const queryClient = useQueryClient();
-    return useMutation({
+    const isWalletConnected = wallet !== null && wallet.publicKey !== null;
+    return Object.assign(Object.assign({}, useMutation({
         mutationFn: async (params) => {
+            if (!client || !wallet) {
+                throw new Error("Wallet not connected");
+            }
             const instruction = await client.ipCore.entity.updateControllersIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: queryKeys.entities() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/grant/useCreateLicenseGrant.d.ts

@@ -25,5 +25,77 @@ import { type TransactionResult } from "../../utils/transaction";
  * }
  * ```
  */
-export declare function useCreateLicenseGrant(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+export declare function useCreateLicenseGrant(): {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: CreateLicenseGrantParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    error: Error;
+    variables: CreateLicenseGrantParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: TransactionResult;
+    error: null;
+    variables: CreateLicenseGrantParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+};
 //# sourceMappingURL=useCreateLicenseGrant.d.ts.map

package/dist/hooks/grant/useCreateLicenseGrant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCreateLicenseGrant.d.ts","sourceRoot":"","sources":["../../../src/hooks/grant/useCreateLicenseGrant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,mHAapC"}
+{"version":3,"file":"useCreateLicenseGrant.d.ts","sourceRoot":"","sources":["../../../src/hooks/grant/useCreateLicenseGrant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBpC"}

package/dist/hooks/grant/useCreateLicenseGrant.js

@@ -31,13 +31,17 @@ import { queryKeys } from "../queries/queryKeys";
 export function useCreateLicenseGrant() {
     const { client, connection, wallet, confirmation } = useMyceliumContext();
     const queryClient = useQueryClient();
-    return useMutation({
+    const isWalletConnected = wallet !== null && wallet.publicKey !== null;
+    return Object.assign(Object.assign({}, useMutation({
         mutationFn: async (params) => {
+            if (!client || !wallet) {
+                throw new Error("Wallet not connected");
+            }
             const instruction = await client.license.grant.createIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: queryKeys.grants() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/grant/useRevokeLicenseGrant.d.ts

@@ -24,5 +24,77 @@ import { type TransactionResult } from "../../utils/transaction";
  * }
  * ```
  */
-export declare function useRevokeLicenseGrant(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+export declare function useRevokeLicenseGrant(): {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    variables: RevokeLicenseGrantParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: undefined;
+    error: Error;
+    variables: RevokeLicenseGrantParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+} | {
+    isWalletConnected: boolean;
+    data: TransactionResult;
+    error: null;
+    variables: RevokeLicenseGrantParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+};
 //# sourceMappingURL=useRevokeLicenseGrant.d.ts.map

package/dist/hooks/grant/useRevokeLicenseGrant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRevokeLicenseGrant.d.ts","sourceRoot":"","sources":["../../../src/hooks/grant/useRevokeLicenseGrant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,qBAAqB,mHAapC"}
+{"version":3,"file":"useRevokeLicenseGrant.d.ts","sourceRoot":"","sources":["../../../src/hooks/grant/useRevokeLicenseGrant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBpC"}

package/dist/hooks/grant/useRevokeLicenseGrant.js

@@ -30,13 +30,17 @@ import { queryKeys } from "../queries/queryKeys";
 export function useRevokeLicenseGrant() {
     const { client, connection, wallet, confirmation } = useMyceliumContext();
     const queryClient = useQueryClient();
-    return useMutation({
+    const isWalletConnected = wallet !== null && wallet.publicKey !== null;
+    return Object.assign(Object.assign({}, useMutation({
         mutationFn: async (params) => {
+            if (!client || !wallet) {
+                throw new Error("Wallet not connected");
+            }
             const instruction = await client.license.grant.revokeIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: queryKeys.grants() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/internal/useMyceliumClient.d.ts

@@ -1,15 +1,17 @@
 import type { MyceliumClient } from "@mycelium-ip/core-sdk";
 /**
- * Returns the MyceliumClient instance from context.
+ * Returns the MyceliumClient instance from context, or null when the wallet
+ * is not yet connected.
  *
  * @throws Error if used outside of MyceliumIpProvider
- * @throws Error if wallet is not connected
  *
  * @example
  * ```ts
  * const client = useMyceliumClient();
- * const ix = await client.ipCore.entity.createIx({ ... });
+ * if (client) {
+ *   const ix = await client.ipCore.entity.createIx({ ... });
+ * }
  * ```
  */
-export declare function useMyceliumClient(): MyceliumClient;
+export declare function useMyceliumClient(): MyceliumClient | null;
 //# sourceMappingURL=useMyceliumClient.d.ts.map

package/dist/hooks/internal/useMyceliumClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMyceliumClient.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useMyceliumClient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAGlD"}
+{"version":3,"file":"useMyceliumClient.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useMyceliumClient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,IAAI,CAGzD"}