@mycelium-ip/react 0.1.0-alpha.0

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

@@ -0,0 +1,30 @@
+import type { CreateDerivativeLinkParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create a derivative link between IPs.
+ *
+ * @example
+ * ```tsx
+ * function CreateDerivativeButton({ parentIp, childIp, childOwner, grant, license }: Props) {
+ *   const { mutate, isPending } = useCreateDerivativeLink();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       parentIp,
+ *       childIp,
+ *       childOwnerEntity: childOwner,
+ *       licenseGrant: grant,
+ *       license,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create Derivative Link
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateDerivativeLink(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateDerivativeLinkParams, unknown>;
+//# sourceMappingURL=useCreateDerivativeLink.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/derivative/useCreateDerivativeLink.js

@@ -0,0 +1,45 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create a derivative link between IPs.
+ *
+ * @example
+ * ```tsx
+ * function CreateDerivativeButton({ parentIp, childIp, childOwner, grant, license }: Props) {
+ *   const { mutate, isPending } = useCreateDerivativeLink();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       parentIp,
+ *       childIp,
+ *       childOwnerEntity: childOwner,
+ *       licenseGrant: grant,
+ *       license,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create Derivative Link
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateDerivativeLink() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.derivative.createIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.derivatives() });
+            queryClient.invalidateQueries({ queryKey: queryKeys.ips() });
+        },
+    });
+}

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

@@ -0,0 +1,30 @@
+import type { UpdateDerivativeLicenseParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to update the license on a derivative link.
+ *
+ * @example
+ * ```tsx
+ * function UpdateDerivativeLicenseButton({ parentIp, childIp, childOwner, newGrant, newLicense }: Props) {
+ *   const { mutate, isPending } = useUpdateDerivativeLicense();
+ *
+ *   const handleUpdate = () => {
+ *     mutate({
+ *       parentIp,
+ *       childIp,
+ *       childOwnerEntity: childOwner,
+ *       newLicenseGrant: newGrant,
+ *       newLicense: newLicense,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleUpdate} disabled={isPending}>
+ *       Update License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useUpdateDerivativeLicense(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, UpdateDerivativeLicenseParams, unknown>;
+//# sourceMappingURL=useUpdateDerivativeLicense.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/derivative/useUpdateDerivativeLicense.js

@@ -0,0 +1,44 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to update the license on a derivative link.
+ *
+ * @example
+ * ```tsx
+ * function UpdateDerivativeLicenseButton({ parentIp, childIp, childOwner, newGrant, newLicense }: Props) {
+ *   const { mutate, isPending } = useUpdateDerivativeLicense();
+ *
+ *   const handleUpdate = () => {
+ *     mutate({
+ *       parentIp,
+ *       childIp,
+ *       childOwnerEntity: childOwner,
+ *       newLicenseGrant: newGrant,
+ *       newLicense: newLicense,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleUpdate} disabled={isPending}>
+ *       Update License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useUpdateDerivativeLicense() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.derivative.updateLicenseIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.derivatives() });
+        },
+    });
+}

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

@@ -0,0 +1,28 @@
+import type { CreateEntityParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create a new entity.
+ *
+ * @example
+ * ```tsx
+ * function CreateEntityButton() {
+ *   const { mutate, isPending, error } = useCreateEntity();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       handle: "my-entity",
+ *       additionalControllers: [],
+ *       signatureThreshold: 1,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       {isPending ? "Creating..." : "Create Entity"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateEntity(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateEntityParams, unknown>;
+//# sourceMappingURL=useCreateEntity.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/entity/useCreateEntity.js

@@ -0,0 +1,42 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create a new entity.
+ *
+ * @example
+ * ```tsx
+ * function CreateEntityButton() {
+ *   const { mutate, isPending, error } = useCreateEntity();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       handle: "my-entity",
+ *       additionalControllers: [],
+ *       signatureThreshold: 1,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       {isPending ? "Creating..." : "Create Entity"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateEntity() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.entity.createIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.entities() });
+        },
+    });
+}

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

@@ -0,0 +1,28 @@
+import type { UpdateEntityControllersParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to update entity controllers.
+ *
+ * @example
+ * ```tsx
+ * function UpdateControllersButton({ entityPubkey }: { entityPubkey: PublicKey }) {
+ *   const { mutate, isPending } = useUpdateEntityControllers();
+ *
+ *   const handleUpdate = () => {
+ *     mutate({
+ *       entity: entityPubkey,
+ *       newControllers: [controller1, controller2],
+ *       newThreshold: 2,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleUpdate} disabled={isPending}>
+ *       Update Controllers
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useUpdateEntityControllers(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, UpdateEntityControllersParams, unknown>;
+//# sourceMappingURL=useUpdateEntityControllers.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/entity/useUpdateEntityControllers.js

@@ -0,0 +1,42 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to update entity controllers.
+ *
+ * @example
+ * ```tsx
+ * function UpdateControllersButton({ entityPubkey }: { entityPubkey: PublicKey }) {
+ *   const { mutate, isPending } = useUpdateEntityControllers();
+ *
+ *   const handleUpdate = () => {
+ *     mutate({
+ *       entity: entityPubkey,
+ *       newControllers: [controller1, controller2],
+ *       newThreshold: 2,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleUpdate} disabled={isPending}>
+ *       Update Controllers
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useUpdateEntityControllers() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.entity.updateControllersIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.entities() });
+        },
+    });
+}

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

@@ -0,0 +1,29 @@
+import type { CreateLicenseGrantParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create a license grant for an entity.
+ *
+ * @example
+ * ```tsx
+ * function CreateGrantButton({ originIp, authorityEntity, granteeEntity }: Props) {
+ *   const { mutate, isPending } = useCreateLicenseGrant();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *       granteeEntity,
+ *       expiration: BigInt(Date.now() + 365 * 24 * 60 * 60 * 1000), // 1 year
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create Grant
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateLicenseGrant(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateLicenseGrantParams, unknown>;
+//# sourceMappingURL=useCreateLicenseGrant.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/grant/useCreateLicenseGrant.js

@@ -0,0 +1,43 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create a license grant for an entity.
+ *
+ * @example
+ * ```tsx
+ * function CreateGrantButton({ originIp, authorityEntity, granteeEntity }: Props) {
+ *   const { mutate, isPending } = useCreateLicenseGrant();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *       granteeEntity,
+ *       expiration: BigInt(Date.now() + 365 * 24 * 60 * 60 * 1000), // 1 year
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create Grant
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateLicenseGrant() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.license.grant.createIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.grants() });
+        },
+    });
+}

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

@@ -0,0 +1,28 @@
+import type { RevokeLicenseGrantParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to revoke a license grant.
+ *
+ * @example
+ * ```tsx
+ * function RevokeGrantButton({ originIp, authorityEntity, granteeEntity }: Props) {
+ *   const { mutate, isPending } = useRevokeLicenseGrant();
+ *
+ *   const handleRevoke = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *       granteeEntity,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleRevoke} disabled={isPending}>
+ *       Revoke Grant
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useRevokeLicenseGrant(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, RevokeLicenseGrantParams, unknown>;
+//# sourceMappingURL=useRevokeLicenseGrant.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/grant/useRevokeLicenseGrant.js

@@ -0,0 +1,42 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to revoke a license grant.
+ *
+ * @example
+ * ```tsx
+ * function RevokeGrantButton({ originIp, authorityEntity, granteeEntity }: Props) {
+ *   const { mutate, isPending } = useRevokeLicenseGrant();
+ *
+ *   const handleRevoke = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *       granteeEntity,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleRevoke} disabled={isPending}>
+ *       Revoke Grant
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useRevokeLicenseGrant() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.license.grant.revokeIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.grants() });
+        },
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { MyceliumClient } from "@mycelium-ip/core-sdk";
+/**
+ * Returns the MyceliumClient instance from context.
+ *
+ * @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({ ... });
+ * ```
+ */
+export declare function useMyceliumClient(): MyceliumClient;
+//# sourceMappingURL=useMyceliumClient.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/internal/useMyceliumClient.js

@@ -0,0 +1,18 @@
+"use client";
+import { useMyceliumContext } from "./useMyceliumContext";
+/**
+ * Returns the MyceliumClient instance from context.
+ *
+ * @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({ ... });
+ * ```
+ */
+export function useMyceliumClient() {
+    const { client } = useMyceliumContext();
+    return client;
+}

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

@@ -0,0 +1,14 @@
+import type { Connection } from "@solana/web3.js";
+/**
+ * Returns the Solana Connection from context.
+ *
+ * @throws Error if used outside of MyceliumIpProvider
+ *
+ * @example
+ * ```ts
+ * const connection = useMyceliumConnection();
+ * const blockhash = await connection.getLatestBlockhash();
+ * ```
+ */
+export declare function useMyceliumConnection(): Connection;
+//# sourceMappingURL=useMyceliumConnection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMyceliumConnection.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useMyceliumConnection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,IAAI,UAAU,CAGlD"}

package/dist/hooks/internal/useMyceliumConnection.js

@@ -0,0 +1,17 @@
+"use client";
+import { useMyceliumContext } from "./useMyceliumContext";
+/**
+ * Returns the Solana Connection from context.
+ *
+ * @throws Error if used outside of MyceliumIpProvider
+ *
+ * @example
+ * ```ts
+ * const connection = useMyceliumConnection();
+ * const blockhash = await connection.getLatestBlockhash();
+ * ```
+ */
+export function useMyceliumConnection() {
+    const { connection } = useMyceliumContext();
+    return connection;
+}

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

@@ -0,0 +1,14 @@
+import { type MyceliumContextValue } from "../../provider/context";
+/**
+ * Returns the full Mycelium context value.
+ *
+ * @throws Error if used outside of MyceliumIpProvider
+ * @throws Error if wallet is not connected (no publicKey)
+ *
+ * @example
+ * ```ts
+ * const { connection, wallet, client, confirmation } = useMyceliumContext();
+ * ```
+ */
+export declare function useMyceliumContext(): MyceliumContextValue;
+//# sourceMappingURL=useMyceliumContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMyceliumContext.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useMyceliumContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,IAAI,oBAAoB,CAWzD"}

package/dist/hooks/internal/useMyceliumContext.js

@@ -0,0 +1,22 @@
+"use client";
+import { useContext } from "react";
+import { MyceliumContext, } from "../../provider/context";
+/**
+ * Returns the full Mycelium context value.
+ *
+ * @throws Error if used outside of MyceliumIpProvider
+ * @throws Error if wallet is not connected (no publicKey)
+ *
+ * @example
+ * ```ts
+ * const { connection, wallet, client, confirmation } = useMyceliumContext();
+ * ```
+ */
+export function useMyceliumContext() {
+    const context = useContext(MyceliumContext);
+    if (context === null) {
+        throw new Error("useMyceliumContext must be used within a MyceliumIpProvider. " +
+            "Make sure your component is wrapped with <MyceliumIpProvider>.");
+    }
+    return context;
+}

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

@@ -0,0 +1,14 @@
+import type { MyceliumWallet } from "../../types/wallet";
+/**
+ * Returns the MyceliumWallet from context.
+ *
+ * @throws Error if used outside of MyceliumIpProvider
+ *
+ * @example
+ * ```ts
+ * const wallet = useMyceliumWallet();
+ * const pubkey = wallet.publicKey;
+ * ```
+ */
+export declare function useMyceliumWallet(): MyceliumWallet;
+//# sourceMappingURL=useMyceliumWallet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMyceliumWallet.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useMyceliumWallet.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAGlD"}

package/dist/hooks/internal/useMyceliumWallet.js

@@ -0,0 +1,17 @@
+"use client";
+import { useMyceliumContext } from "./useMyceliumContext";
+/**
+ * Returns the MyceliumWallet from context.
+ *
+ * @throws Error if used outside of MyceliumIpProvider
+ *
+ * @example
+ * ```ts
+ * const wallet = useMyceliumWallet();
+ * const pubkey = wallet.publicKey;
+ * ```
+ */
+export function useMyceliumWallet() {
+    const { wallet } = useMyceliumContext();
+    return wallet;
+}

package/dist/hooks/ip/useCreateIp.d.ts

@@ -0,0 +1,29 @@
+import type { CreateIpParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create a new IP (Intellectual Property) asset.
+ *
+ * @example
+ * ```tsx
+ * function CreateIpButton({ entityPubkey }: { entityPubkey: PublicKey }) {
+ *   const { mutate, isPending } = useCreateIp();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       registrantEntity: entityPubkey,
+ *       content: new TextEncoder().encode("ip-content-hash"),
+ *       treasuryTokenAccount: treasuryAccount,
+ *       payerTokenAccount: payerAccount,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create IP
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateIp(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateIpParams, unknown>;
+//# sourceMappingURL=useCreateIp.d.ts.map

package/dist/hooks/ip/useCreateIp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateIp.d.ts","sourceRoot":"","sources":["../../../src/hooks/ip/useCreateIp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,yGAa1B"}