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

package/dist/hooks/metadata/useCreateEntityMetadata.d.ts

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

package/dist/hooks/metadata/useCreateEntityMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCreateEntityMetadata.d.ts","sourceRoot":"","sources":["../../../src/hooks/metadata/useCreateEntityMetadata.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,qHAetC"}
+{"version":3,"file":"useCreateEntityMetadata.d.ts","sourceRoot":"","sources":["../../../src/hooks/metadata/useCreateEntityMetadata.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BtC"}

package/dist/hooks/metadata/useCreateEntityMetadata.js

@@ -32,8 +32,12 @@ import { queryKeys } from "../queries/queryKeys";
 export function useCreateEntityMetadata() {
     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.metadata.createEntityMetadataIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
@@ -41,5 +45,5 @@ export function useCreateEntityMetadata() {
             queryClient.invalidateQueries({ queryKey: queryKeys.entities() });
             queryClient.invalidateQueries({ queryKey: queryKeys.metadata() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/metadata/useCreateIpMetadata.d.ts

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

package/dist/hooks/metadata/useCreateIpMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCreateIpMetadata.d.ts","sourceRoot":"","sources":["../../../src/hooks/metadata/useCreateIpMetadata.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,iHAelC"}
+{"version":3,"file":"useCreateIpMetadata.d.ts","sourceRoot":"","sources":["../../../src/hooks/metadata/useCreateIpMetadata.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BlC"}

package/dist/hooks/metadata/useCreateIpMetadata.js

@@ -33,8 +33,12 @@ import { queryKeys } from "../queries/queryKeys";
 export function useCreateIpMetadata() {
     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.metadata.createIpMetadataIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
@@ -42,5 +46,5 @@ export function useCreateIpMetadata() {
             queryClient.invalidateQueries({ queryKey: queryKeys.ips() });
             queryClient.invalidateQueries({ queryKey: queryKeys.metadata() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/hooks/metadata/useCreateMetadataSchema.d.ts

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

package/dist/hooks/metadata/useCreateMetadataSchema.d.ts.map

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

package/dist/hooks/metadata/useCreateMetadataSchema.js

@@ -31,13 +31,17 @@ import { queryKeys } from "../queries/queryKeys";
 export function useCreateMetadataSchema() {
     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.metadata.createSchemaIx(params);
             return executeTransaction(connection, wallet, instruction, confirmation);
         },
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: queryKeys.metadata() });
         },
-    });
+    })), { isWalletConnected });
 }

package/dist/provider/MyceliumIpProvider.d.ts

@@ -23,8 +23,8 @@ export interface MyceliumIpProviderOptions {
 export interface MyceliumIpProviderProps {
     /** Solana RPC connection (required) */
     connection: Connection;
-    /** Wallet implementing the MyceliumWallet interface (required) */
-    wallet: MyceliumWallet;
+    /** Wallet implementing the MyceliumWallet interface (optional; mutations will throw when null/undefined) */
+    wallet?: MyceliumWallet | null;
     /**
      * Existing TanStack Query client.
      * If omitted, the provider creates one.

package/dist/provider/MyceliumIpProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MyceliumIpProvider.d.ts","sourceRoot":"","sources":["../../src/provider/MyceliumIpProvider.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAuB,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,YAAY,CAAC,EAAE,UAAU,CAAC;IAE1B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,uCAAuC;IACvC,UAAU,EAAE,UAAU,CAAC;IAEvB,kEAAkE;IAClE,MAAM,EAAE,cAAc,CAAC;IAEvB;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B,uBAAuB;IACvB,OAAO,CAAC,EAAE,yBAAyB,CAAC;IAEpC,uBAAuB;IACvB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAaD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,UAAU,EACV,MAAM,EACN,WAAW,EACX,OAAO,EACP,QAAQ,GACT,EAAE,uBAAuB,2CA0DzB"}
+{"version":3,"file":"MyceliumIpProvider.d.ts","sourceRoot":"","sources":["../../src/provider/MyceliumIpProvider.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAuB,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,YAAY,CAAC,EAAE,UAAU,CAAC;IAE1B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,uCAAuC;IACvC,UAAU,EAAE,UAAU,CAAC;IAEvB,4GAA4G;IAC5G,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IAE/B;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B,uBAAuB;IACvB,OAAO,CAAC,EAAE,yBAAyB,CAAC;IAEpC,uBAAuB;IACvB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAaD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,UAAU,EACV,MAAM,EACN,WAAW,EACX,OAAO,EACP,QAAQ,GACT,EAAE,uBAAuB,2CAuDzB"}

package/dist/provider/MyceliumIpProvider.js

@@ -40,8 +40,8 @@ export function MyceliumIpProvider({ connection, wallet, queryClient, options, c
     // Create the core SDK client
     const client = useMemo(() => {
         var _a;
-        // Only create client if wallet has a public key
-        if (!wallet.publicKey) {
+        // Only create client if wallet exists and has a public key
+        if (!(wallet === null || wallet === void 0 ? void 0 : wallet.publicKey)) {
             return null;
         }
         return new MyceliumClient({
@@ -60,14 +60,12 @@ export function MyceliumIpProvider({ connection, wallet, queryClient, options, c
             },
         });
     }, [connection, wallet]);
-    // Create context value
+    // Create context value — always non-null inside the provider;
+    // wallet and client are null when the wallet is not yet connected.
     const contextValue = useMemo(() => {
-        if (!client) {
-            return null;
-        }
         return {
             connection,
-            wallet,
+            wallet: wallet !== null && wallet !== void 0 ? wallet : null,
             client,
             confirmation,
         };

package/dist/provider/context.d.ts

@@ -7,10 +7,10 @@ import type { MyceliumWallet } from "../types/wallet";
 export interface MyceliumContextValue {
     /** Solana RPC connection */
     connection: Connection;
-    /** Wallet implementing the MyceliumWallet interface */
-    wallet: MyceliumWallet;
-    /** Core SDK client instance */
-    client: MyceliumClient;
+    /** Wallet implementing the MyceliumWallet interface, or null when not connected */
+    wallet: MyceliumWallet | null;
+    /** Core SDK client instance, or null when wallet is not connected */
+    client: MyceliumClient | null;
     /** Transaction confirmation level */
     confirmation: Commitment;
 }

package/dist/provider/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/provider/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,4BAA4B;IAC5B,UAAU,EAAE,UAAU,CAAC;IACvB,uDAAuD;IACvD,MAAM,EAAE,cAAc,CAAC;IACvB,+BAA+B;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,qCAAqC;IACrC,YAAY,EAAE,UAAU,CAAC;CAC1B;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,sDAAmD,CAAC"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/provider/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,4BAA4B;IAC5B,UAAU,EAAE,UAAU,CAAC;IACvB,mFAAmF;IACnF,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IAC9B,qEAAqE;IACrE,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IAC9B,qCAAqC;IACrC,YAAY,EAAE,UAAU,CAAC;CAC1B;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,sDAAmD,CAAC"}

package/dist/utils/transaction.d.ts

@@ -24,7 +24,7 @@ export interface TransactionResult {
  *
  * @throws Error if wallet is not connected (no publicKey)
  */
-export declare function executeTransaction(connection: Connection, wallet: MyceliumWallet, instruction: TransactionInstruction, confirmation: Commitment): Promise<TransactionResult>;
+export declare function executeTransaction(connection: Connection, wallet: MyceliumWallet | null, instruction: TransactionInstruction, confirmation: Commitment): Promise<TransactionResult>;
 /**
  * Execute multiple instructions in a single transaction.
  *

package/dist/utils/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../src/utils/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,sBAAsB,EACnC,YAAY,EAAE,UAAU,GACvB,OAAO,CAAC,iBAAiB,CAAC,CAkC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kCAAkC,CACtD,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,sBAAsB,EAAE,EACtC,YAAY,EAAE,UAAU,GACvB,OAAO,CAAC,iBAAiB,CAAC,CAqC5B"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../src/utils/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,cAAc,GAAG,IAAI,EAC7B,WAAW,EAAE,sBAAsB,EACnC,YAAY,EAAE,UAAU,GACvB,OAAO,CAAC,iBAAiB,CAAC,CAkC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kCAAkC,CACtD,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,sBAAsB,EAAE,EACtC,YAAY,EAAE,UAAU,GACvB,OAAO,CAAC,iBAAiB,CAAC,CAqC5B"}

package/dist/utils/transaction.js

@@ -17,7 +17,7 @@ import { Transaction } from "@solana/web3.js";
  * @throws Error if wallet is not connected (no publicKey)
  */
 export async function executeTransaction(connection, wallet, instruction, confirmation) {
-    if (!wallet.publicKey) {
+    if (!(wallet === null || wallet === void 0 ? void 0 : wallet.publicKey)) {
         throw new Error("Wallet not connected");
     }
     // Build the transaction

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycelium-ip/react",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "private": false,
   "type": "module",
   "description": "React hooks for the Mycelium IP protocol",