@monerium/sdk-react-provider 0.1.0 → 0.2.0

package/README.md

@@ -1,50 +1,104 @@
+| [Monerium.com](https://monerium.com/) | [Monerium.app](https://monerium.app/) | [Monerium.dev](https://monerium.dev/) |
+| ------------------------------------- | ------------------------------------- | ------------------------------------- |
+
 # Monerium SDK React Provider
 
+  <a href="https://monerium.dev/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/badge/Developer_portal-2c6ca7">
+      <img src="https://img.shields.io/badge/Developer_portal-2c6ca7" alt="Static Badge">
+    </picture>
+  </a>
+  <a href="https://monerium.dev/api-docs">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/badge/API_documentation-2c6ca7">
+      <img src="https://img.shields.io/badge/API_documentation-2c6ca7" alt="Static Badge">
+    </picture>
+  </a>
+  </br>
+    <a href="https://www.npmjs.com/package/@monerium/sdk-react-provider">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/npm/v/%40monerium%2Fsdk-react-provider?colorA=2c6ca7&colorB=21262d">
+      <img src="https://img.shields.io/npm/v/%40monerium%2Fsdk-react-provider?colorA=f6f8fa&colorB=f6f8fa" alt="Version">
+    </picture>
+  </a>
+  <a href="https://github.com/monerium/js-monorepo/issues>
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/issues/monerium/js-monorepo?colorA=2c6ca7&colorB=21262d">
+      <img src="https://img.shields.io/github/issues/monerium/js-monorepo?colorA=2c6ca7&colorB=21262d" alt="Version">
+    </picture>
+  </a>
+
 ## Installation
 
 ```
-pnpm add @monerium/sdk-react-provider
+pnpm add @monerium/sdk-react-provider @tanstack/react-query
 ```
 
-# Usage
+- [TanStack Query](https://tanstack.com/query/v5) is an async state manager that handles requests, caching, and more.
+
+### Wrap App in Context Provider
 
-Wrap the application with the provider and pass the configuration as props.
+Wrap your app in the `QueryClientProvider` React Context Provider and pass a new `QueryClient` instance to the `client` property
+
+Inside the `QueryClientProvider`, wrap your app in the `MoneriumProvider` React Context Provider and pass the auth flow's `clientId`, `redirectUrl`, and `environment` configuration.
 
 ```tsx
 import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
 import { MoneriumProvider } from '@monerium/sdk-react-provider';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 
 import App from './App';
 
 const rootElement = document.getElementById('root');
 const root = createRoot(rootElement);
 
+const queryClient = new QueryClient();
+
 root.render(
   <StrictMode>
-    <MoneriumProvider
-      clientId="f99e629b-6dca-11ee-8aa6-5273f65ed05b"
-      redirectUrl="https://pntvgs.csb.app/"
-      environment="sandbox"
-    >
-      <App />
-    </MoneriumProvider>
+    <QueryClientProvider client={queryClient}>
+      <MoneriumProvider
+        clientId="f99e629b-6dca-11ee-8aa6-5273f65ed05b"
+        redirectUrl="https://pntvgs.csb.app/"
+        environment="sandbox"
+      >
+        <App />
+      </MoneriumProvider>
+    </QueryClientProvider>
   </StrictMode>
 );
 ```
 
-Use the hook to access the Monerium SDK.
+## Hooks
+
+The following hooks are now available within your application:
+
+[useAuth](./docs/generated/functions/useAuth.md)</br>
+[useAuthContext](./docs/generated/functions/useAuthContext.md)</br>
+[useBalances](./docs/generated/functions/useBalances.md)</br>
+[useLinkAddress](./docs/generated/functions/useLinkAddress.md)</br>
+[useOrder](./docs/generated/functions/useOrder.md)</br>
+[useOrders](./docs/generated/functions/useOrders.md)</br>
+[usePlaceOrder](./docs/generated/functions/usePlaceOrder.md)</br>
+[useProfile](./docs/generated/functions/useProfile.md)</br>
+[useProfiles](./docs/generated/functions/useProfiles.md)</br>
+[useTokens](./docs/generated/functions/useTokens.md)</br>
+
+### Example
 
 ```tsx
-import { useMonerium } from '@monerium/sdk-react-provider';
+import { useAuth, useProfile } from '@monerium/sdk-react-provider';
 
 export default function App() {
-  const { authorize, isAuthorized, profile, balances, tokens, orders } =
-    useMonerium();
+  const { authorize, isAuthorized } = useAuth();
+  const { profile } = useProfile();
+
   return (
     <div className="App">
       {!isAuthorized && <button onClick={authorize}>Authorize</button>}
-      <h1>Hello {profile ? profile?.email : 'CodeSandbox'}</h1>
+      {profile ? <h1>{profile?.email}</h1> : <h1>No profile</h1>}
     </div>
   );
 }
@@ -59,8 +113,52 @@ Hook used to access the SDK: https://codesandbox.io/s/monerium-sdk-react-provide
 The application is wrapped with MoneriumProvider
 https://codesandbox.io/s/monerium-sdk-react-provider-pntvgs?file=/src/index.js
 
+# Development
+
 ## Running unit tests
 
 Run `turbo --filter @monerium/sdk-react-provider test` to execute the unit tests
 
-####
+## Documentation
+
+We use [TypeDoc](https://typedoc.org/) to generate the documentation.
+
+There are a few caveats to keep in mind when documenting the code:
+
+- Use `@group` to group functions in the entry file. E.g. `@group Hooks`.
+- To specifically mark `@param` as optional, use square brackets, e.g. `[param]`. Useful for optional destructed parameters.
+- For optional destructed parameters, use inline typing to improve readability.
+
+  ```diff
+  + @param {Object} [param] - Optional parameter.
+  + @param {MyQueryType} [param.query] - Description.
+  +
+  + function useMyHook(
+  +   { query }:
+  +   { query?: MyQueryType } = {}
+  + ) {}
+  ```
+
+  Document output:
+
+  ```ts
+  param?: Object
+  param?.query MyQueryType
+  ```
+
+  Instead of:
+
+  ```diff
+  - type UseMyHookParams = {
+  -   query?: MyQueryType
+  - }
+  - function useMyHook(params?: UseHookParams) {}
+  ```
+
+  Document output:
+
+  ```ts
+  params?: UseMyHookParams
+  ```
+
+  > This would require the viewer to navigate into the `UseMyHookParams` type to see the optional `query` property.

package/dist/index.d.ts

@@ -1,35 +1,544 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { FC, ReactNode } from 'react';
-import { Profile, Balances, LinkAddress, NewOrder, Order, Token } from '@monerium/sdk';
+import { ReactNode } from 'react';
+import { UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import MoneriumClient, { ChainId, AuthContext, Profile, Token, Balances, Order, OrderState, NewOrder, LinkedAddress, LinkAddress } from '@monerium/sdk';
+export { AuthContext, Balances, LinkAddress, Order, OrderState, Profile, Token } from '@monerium/sdk';
 
-interface MoneriumProviderProps {
+/**
+ * Place this provider at the root of your application.
+ * @group Provider
+ * @param params
+ * @param params.children - Rest of the application.
+ * @param params.clientId - Monerium auth flow client id.
+ * @param params.redirectUrl - Monerium auth flow redirect url.
+ * @param params.environment - Monerium environment.
+ * @returns
+ */
+declare const MoneriumProvider: ({ children, clientId, redirectUrl, environment, }: {
     children: ReactNode;
     clientId?: string;
     redirectUrl?: string;
-    environment?: 'sandbox' | 'production';
-}
-declare const MoneriumProvider: FC<MoneriumProviderProps>;
+    environment?: "sandbox" | "production";
+}) => react_jsx_runtime.JSX.Element;
 
-interface MoneriumContextValue {
-    authorize: () => Promise<void>;
+type SdkInstance = {
+    /** Monerium SDK instance. */
+    sdk?: MoneriumClient;
+};
+type AuthorizeParams = {
+    address: string;
+    signature: string;
+    chainId?: ChainId;
+} | {
+    state?: string;
+    scope?: string;
+} | {};
+type UseAuthReturn = {
+    /**
+     * Constructs the url and redirects to the Monerium auth flow.
+     */
+    authorize: (params?: AuthorizeParams) => Promise<void>;
+    /**
+     * Indicates whether the SDK is authorized.
+     */
     isAuthorized: boolean;
-    profile: Profile | null;
-    balances: Balances[] | null;
-    loading: boolean;
-    loadingPlaceOrder: boolean;
-    loadingLinkAddress: boolean;
-    loadingBalances: boolean;
-    getBalances: () => Promise<void>;
-    linkAddress: (addressDetails: LinkAddress) => Promise<unknown>;
-    placeOrder: (orderDetails: NewOrder, supportingDocument?: File) => Promise<void>;
-    orders: Order[];
-    tokens: Token[];
+    /**
+     * Indicates whether the SDK authorization is loading.
+     */
+    isLoading: boolean;
     error: unknown;
-    /** Is still checking if there is an active session */
-    loadingAuth: boolean;
-}
-declare const MoneriumContext: react.Context<MoneriumContextValue | null>;
+    disconnect: () => Promise<void>;
+    revokeAccess: () => Promise<void>;
+};
+/**
+ * See [Tanstack Query - useQuery](https://tanstack.com/query/latest/docs/framework/react/reference/useQuery) options.
+ * @see # [Tanstack Query - useQuery](https://tanstack.com/query/latest/docs/framework/react/reference/useQuery)
+ * @template {Object} TData - The data returned.
+ *
+ * @options
+ * > `queryKey` and `queryFn` are used internally and therefore not included in the options.
+ * ```diff
+ * query: {
+ * -  queryKey,
+ * -  queryFn,
+ *    gcTime,
+ *    enabled,
+ *    networkMode,
+ *    initialData,
+ *    initialDataUpdatedAt,
+ *    meta,
+ *    notifyOnChangeProps,
+ *    placeholderData,
+ *    queryKeyHashFn,
+ *    refetchInterval,
+ *    refetchIntervalInBackground,
+ *    refetchOnMount,
+ *    refetchOnReconnect,
+ *    refetchOnWindowFocus,
+ *    retry,
+ *    retryOnMount,
+ *    retryDelay,
+ *    select,
+ *    staleTime,
+ *    structuralSharing,
+ *    throwOnError
+ * }
+ *  ```
+ * @example
+ * ```ts
+ * useQueryHook({
+ *  query: {
+ *    enabled: isReady,
+ *    staleTime: 1000,
+ *    placeHolderData: { foo: 'bar' },
+ *  }
+ * })
+ * ```
+ * @usedBy
+ * {@link useAuthContext}
+ *
+ * {@link useBalances}
+ *
+ * {@link useOrders}
+ *
+ * {@link useProfile}
+ *
+ * {@link useTokens}
+ */
+type QueryOptions<TData = unknown> = Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>;
+/**
+ * See [Tanstack Query - useQuery](https://tanstack.com/query/latest/docs/framework/react/reference/useQuery) returns.
+ * @see # [Tanstack Query - useQuery](https://tanstack.com/query/latest/docs/framework/react/reference/useQuery)
+ *
+ * @template {string} TVarName - The name of the variable that returns the data.
+ * @template {Object} TData - The data returned.
+ *
+ * @example
+ * > `data` is renamed according to the `TVarName` and therefore not included in the result.
+ * ```diff
+ * {
+ * -   data,
+ *    dataUpdatedAt,
+ *    error,
+ *    errorUpdatedAt,
+ *    failureCount,
+ *    failureReason,
+ *    fetchStatus,
+ *    isError,
+ *    isFetched,
+ *    isFetchedAfterMount,
+ *    isFetching,
+ *    isInitialLoading,
+ *    isLoading,
+ *    isLoadingError,
+ *    isPaused,
+ *    isPending,
+ *    isPlaceholderData,
+ *    isRefetchError,
+ *    isRefetching,
+ *    isStale,
+ *    isSuccess,
+ *    refetch,
+ *    status,
+ *}
+ *  ```
+ * @usedBy
+ * {@link useAuthContext}
+ *
+ * {@link useBalances}
+ *
+ * {@link useOrders}
+ *
+ * {@link useProfile}
+ *
+ * {@link useTokens}
+ *
+ */
+type QueryResult<TVarName extends string, TData = unknown> = Omit<UseQueryResult<TData>, 'data'> & {
+    [P in TVarName]: UseQueryResult<TData>['data'];
+};
+/**
+ * See [Tanstack Query - useMutation](https://tanstack.com/query/latest/docs/framework/react/reference/useMutation) options.
+ * @see # [Tanstack Query - useMutation](https://tanstack.com/query/latest/docs/framework/react/reference/useMutation)
+ *
+ * @template {Object} TData - The data returned.
+ * @template {Object} TError - The error returned.
+ * @template {Object} TVariables - The variables used in the mutation.
+ *
+ * @options
+ * > `mutationKey` and `mutationFn` are used internally and therefore not included in the options.
+ * ```diff
+ * mutation: {
+ *    gcTime,
+ *    meta,
+ * -  mutationFn,
+ * -  mutationKey,
+ *    networkMode,
+ *    onError,
+ *    onMutate,
+ *    onSettled,
+ *    onSuccess,
+ *    retry,
+ *    retryDelay,
+ *    scope,
+ *    throwOnError,
+ * }
+ *  ```
+ * @example
+ * ```ts
+ * useMutationHook({
+ *  mutation: {
+ *    onSuccess: (data, variables) => {
+ *      console.log('onSuccess callback', data, variables);
+ *    },
+ *    onError: (error) => {
+ *      console.log('onError callback', error);
+ *    },
+ *  },
+ * })
+ * ```
+ *
+ * @usedBy
+ * {@link useLinkAddress}
+ *
+ * {@link usePlaceOrder}
+ */
+type MutationOptions<TData = unknown, TError = unknown, TVariables = unknown> = Omit<UseMutationOptions<TData, TError, TVariables>, 'mutationKey' | 'mutationFn'>;
+/**
+ * See [Tanstack Query - useMutation](https://tanstack.com/query/latest/docs/framework/react/reference/useMutation) returns.
+ * @see # [Tanstack Query - useMutation](https://tanstack.com/query/latest/docs/framework/react/reference/useMutation)
+ *
+ * @template {string} TFuncName - The name of the function that mutates.
+ * @template {Object} TData - The data returned.
+ * @template {Object} TError - The error returned.
+ * @template {Object} TVariables - The variables used in the mutation.
+ * @template {Object} TContext - The context used in the mutation.
+ *
+ * @example
+ * > `mutateAsync` is renamed according to the `TFuncName` and therefore not included in the result.
+ * ```diff
+ * const {
+ *    data,
+ *    error,
+ *    isError,
+ *    isIdle,
+ *    isPending,
+ *    isPaused,
+ *    isSuccess,
+ *    failureCount,
+ *    failureReason,
+ *    mutate,
+ * -  mutateAsync,
+ *    reset,
+ *    status,
+ *    submittedAt,
+ *    variables,
+ * } = useMutationHook();
+ *  ```
+ * @usedBy
+ * {@link useLinkAddress}
+ *
+ * {@link usePlaceOrder}
+ */
+type MutationResult<TFuncName extends string, TData, TError, TVariables, TContext = unknown> = Omit<UseMutationResult<TData, TError, TVariables, TContext>, 'mutateAsync'> & {
+    [P in TFuncName]: UseMutationResult<TData, TError, TVariables, TContext>['mutateAsync'];
+};
 
-declare function useMonerium(): MoneriumContextValue;
+declare const MoneriumContext: react.Context<(UseAuthReturn & SdkInstance) | null>;
 
-export { MoneriumContext, type MoneriumContextValue, MoneriumProvider, useMonerium };
+/**
+ * @internal
+ * Query keys
+ * */
+declare const keys: {
+    getAll: string[];
+    getAuthContext: string[];
+    getProfile: (profileId: string) => string[];
+    getProfiles: string[];
+    getBalances: (profileId?: string) => string[];
+    getTokens: string[];
+    getOrder: (orderId: string) => string[];
+    getOrders: (filter?: unknown) => {}[];
+    placeOrder: string[];
+    linkAddress: string[];
+};
+/**
+ * # Redirect to the Monerium auth flow.
+ * @group Hooks
+ * @example
+ * ```ts
+ * const { authorize, isAuthorized, isLoading, error } = useAuth();
+ *
+ * authorize(); // Redirects to the Monerium auth flow.
+ *
+ * // To opt-in to automated wallet linking, pass the address, signature and chainId.
+ * authorize({ address, signature, chainId }).
+ * ```
+ *
+ * @returns {UseAuthReturn}
+ * - `authorize`  - Redirects to the Monerium auth flow.
+ * - `isAuthorized` - Whether the user is authorized.
+ * - `isLoading` - Whether the auth flow is loading.
+ * - `error` - Error message if the auth flow fails.
+ * - `disconnect` - Disconnect the user.
+ * - `revokeAccess` - Revoke the user's access.
+ */
+declare function useAuth(): UseAuthReturn;
+/**
+ * # Get the authentication context.
+ * @group Hooks
+ *
+ * @param {Object} [params] No required parameters.
+ * @param {QueryOptions<AuthContext>} [params.query] {@inheritDoc QueryOptions}
+ *
+ * @example
+ * ```ts
+ * const {
+ *    authContext, // useQuery's `data` property
+ *    isLoading,
+ *    isError,
+ *    error,
+ *    refetch,
+ *    ...moreUseQueryResults
+ * } = useAuthContext();
+ * ```
+ *
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/auth-context)
+ *
+ * [AuthContext interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/AuthContext.md)
+ */
+declare function useAuthContext({ query, }?: {
+    query?: QueryOptions<AuthContext>;
+}): QueryResult<'authContext', AuthContext>;
+/**
+ * # Get single profile
+ * If no `profileId` is provided, the default profile is used.
+ * @group Hooks
+ * @param {Object} params
+ * @param {string} [params.profileId] The id of the profile.
+ * @param {QueryOptions<Profile>} [params.query] {@inheritDoc QueryOptions}
+ *
+ * @example
+ * ```ts
+ * const {
+ *    profile, // useQuery's `data` property
+ *    isLoading,
+ *    isError,
+ *    error,
+ *    refetch,
+ *    ...moreUseQueryResults
+ * } = useProfile();
+ * ```
+
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/profile)
+ *
+ * [Profile interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Profile.md)
+ */
+declare function useProfile({ profileId, query, }?: {
+    profileId?: string;
+    query?: QueryOptions<Profile>;
+}): QueryResult<'profile', Profile>;
+/**
+ * # Get profiles
+ * @group Hooks
+ * @param {Object} [params] No required parameters.
+ * @param {QueryOptions<Profile[]>} [params.query] {@inheritDoc QueryOptions}
+ *
+ * @example
+ * ```ts
+ * const {
+ *    profiles, // useQuery's `data` property
+ *    isLoading,
+ *    isError,
+ *    error,
+ *    refetch,
+ *    ...moreUseQueryResults
+ * } = useProfiles();
+ * ```
+
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/profiles)
+ *
+ * [Profile interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Profile.md)
+ */
+declare function useProfiles({ query, }?: {
+    query?: QueryOptions<Profile[]>;
+}): QueryResult<'profiles', Profile[]>;
+/**
+ * # Get tokens
+ * @group Hooks
+ * @param {Object} [params] No required parameters.
+ * @param {QueryOptions<Token[]>} [params.query] {@inheritDoc QueryOptions}
+ *
+ * @example
+ * ```ts
+ * const {
+ *    tokens, // useQuery's `data` property
+ *    isLoading,
+ *    isError,
+ *    error,
+ *    refetch,
+ *    ...moreUseQueryResults
+ * } = useTokens();
+ * ```
+
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/tokens)
+ *
+ * [Token interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Token.md)
+ */
+declare function useTokens({ query, }?: {
+    query?: QueryOptions<Token[]>;
+}): QueryResult<'tokens', Token[]>;
+/**
+ * # Get balances
+ * @group Hooks
+ * @param {Object} [params] No required parameters.
+ * @param {QueryOptions<Balances[]>} [params.profileId] Fetch balances for a specific profile.
+ * @param {QueryOptions<Balances[]>} [params.query] {@inheritDoc QueryOptions}
+
+ * @example
+ * ```ts
+ * const {
+ *    balances, // useQuery's `data` property
+ *    isLoading,
+ *    isError,
+ *    error,
+ *    refetch,
+ *    ...moreUseQueryResults
+ * } = useBalances();
+ * ```
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/profile-balances)
+ *
+ * [Balances interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Balances.md)
+ */
+declare function useBalances({ profileId, query, }?: {
+    profileId?: string;
+    query?: QueryOptions<Balances[]>;
+}): QueryResult<'balances', Balances[]>;
+/**
+ * # Get single order
+ * @group Hooks
+ * @param {Object} params
+ * @param {Object} params.orderId The id of the order.
+ * @param {QueryOptions<Order>} [params.query] {@inheritDoc QueryOptions}
+ * @example
+ * ```ts
+ * const {
+ *    order, // useQuery's `data` property
+ *    isLoading,
+ *    isError,
+ *    error,
+ *    refetch,
+ *    ...moreUseQueryResults
+ * } = useOrder();
+ * ```
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/order)
+ *
+ * [Order interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Order.md)
+ */
+declare function useOrder({ orderId, query, }: {
+    orderId: string;
+    query?: QueryOptions<Order>;
+}): QueryResult<'order', Order>;
+/**
+ * # Get orders
+ * @group Hooks
+ * @param {Object} [params] No required parameters.
+ * @param {Object} [params.address] Filter based on the blockchain address associated with the order.
+ * @param {Object} [params.memo] Filter by the payment memo/reference..
+ * @param {Object} [params.profile] Filter based on the profile ID associated with the order.
+ * @param {Object} [params.state] Filter based on the state of the order.
+ * @param {Object} [params.txHash] Filter based on the blockchain transaction hash.
+ * @param {QueryOptions<Order[]>} [params.query] {@inheritDoc QueryOptions}
+ *
+ * @example
+ * ```ts
+ * const {
+ *    orders, // useQuery's `data` property
+ *    isLoading,
+ *    isError,
+ *    error,
+ *    refetch,
+ *    ...moreUseQueryResults
+ * } = useOrders();
+ * ```
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/orders)
+ *
+ * [Order interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Order.md)
+ */
+declare function useOrders({ query, ...filters }?: {
+    query?: QueryOptions<Order[]>;
+    address?: string;
+    txHash?: string;
+    profile?: string;
+    memo?: string;
+    state?: OrderState;
+}): QueryResult<'orders', Order[]>;
+/**
+ * # Place an order.
+ * When the order has been placed, the orders query will be invalidated and re-fetched.
+ *
+ * If the order amount is above 15000, a supporting document is required.
+ * @group Hooks
+ * @param param
+ * @param {File} param.supportingDocument Supporting document file.
+ * @param {Object} param.mutation {@inheritDoc MutationOptions}
+ *
+ * @example
+ * ```ts
+ * const {
+ *    placeOrder, // useMutation's `mutateAsync` property
+ *    isPending,
+ *    isError,
+ *    error,
+ *    status,
+ *    ...moreUseMutationResults
+ * } = usePlaceOrder();
+ * ```
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/post-orders)
+ *
+ * [NewOrder type](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/type-aliases/NewOrder.md)
+ */
+declare function usePlaceOrder({ supportingDocument, mutation, }?: {
+    supportingDocument?: File;
+    mutation?: MutationOptions<Order, Error, NewOrder>;
+}): MutationResult<'placeOrder', Order, Error, NewOrder>;
+/**
+ * # Add address to profile.
+ * When the address has been linked, the relevant profile query will be invalidated and re-fetched.
+ *
+ * @group Hooks
+ * @param param
+ * @param {File} param.profileId Which profile to link the address.
+ * @param {Object} param.mutation {@inheritDoc MutationOptions}
+ *
+ * @example
+ * ```ts
+ * const {
+ *    linkAddress, // useMutation's `mutateAsync` property
+ *    isPending,
+ *    isError,
+ *    error,
+ *    status,
+ *    ...moreUseMutationResults
+ * } = useLinkAddress();
+ * ```
+ * @see
+ * [API Documentation](https://monerium.dev/api-docs#operation/profile-addresses)
+ *
+ * [LinkAddress interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/LinkAddress.md)
+ */
+declare function useLinkAddress({ profileId, mutation, }: {
+    profileId: string;
+    mutation?: MutationOptions<LinkedAddress, Error, LinkAddress>;
+}): MutationResult<'linkAddress', LinkedAddress, Error, LinkAddress>;
+
+export { type AuthorizeParams, MoneriumContext, MoneriumProvider, type MutationOptions, type MutationResult, type QueryOptions, type QueryResult, type SdkInstance, type UseAuthReturn, keys, useAuth, useAuthContext, useBalances, useLinkAddress, useOrder, useOrders, usePlaceOrder, useProfile, useProfiles, useTokens };

package/dist/index.js

@@ -1,13 +1,24 @@
 'use strict';
 
 var react = require('react');
+var reactQuery = require('@tanstack/react-query');
 var sdk = require('@monerium/sdk');
 var jsxRuntime = require('react/jsx-runtime');
 
-var c=react.createContext(null);var ae=({children:i,clientId:A="f99e629b-6dca-11ee-8aa6-5273f65ed05b",redirectUrl:O="http://localhost:5173",environment:b="sandbox"})=>{let[e,y]=react.useState(),[t,C]=react.useState(!1),[l,M]=react.useState(null),[v,L]=react.useState(null),[B,g]=react.useState(!1),[D,p]=react.useState(!1),[E,h]=react.useState(!1),[z,k]=react.useState(!1),[N,s]=react.useState(null),[T,P]=react.useState([]),[F,I]=react.useState([]),[V,R]=react.useState(!0);react.useEffect(()=>{let r=new sdk.MoneriumClient({environment:b,clientId:A,redirectUrl:O});y(r);},[]),react.useEffect(()=>((async()=>{if(e)try{C(await e.getAccess());}catch(o){console.error("Failed to get access:",o);}finally{R(!1);}})(),()=>{e&&e.disconnect();}),[e]),react.useEffect(()=>{(async()=>{if(e&&t)try{g(!0);let[o]=await Promise.all([e.getAuthContext(),w()]),[a,u]=await Promise.all([e.getProfile(o.defaultProfile),e.getTokens()]),f=await e.getOrders();M(a),P(f),I(u);}catch(o){console.error("Error fetching data:",o),s(o);}finally{g(!1);}})();},[e,t]);let S=react.useCallback(async()=>{try{e&&await e.authorize();}catch(r){console.error("Error during authorization:",r),s(r);}},[e]),w=react.useCallback(async()=>{if(e&&t)try{k(!0);let r=await e.getBalances();L(r);}catch(r){console.error("Error getting balances:",r),s(r);}finally{k(!1);}},[e,t]),U=react.useCallback(async(r,o)=>{if(e&&t)try{p(!0);let a;parseInt(r.amount)>15e3&&o&&(a=(await e.uploadSupportingDocument(o)).id);let u={...r,documentId:a},f=await e.placeOrder(u);P(x=>[...x,f]);}catch(a){console.error("Error placing order:",a),s(a);}finally{p(!1);}},[e,t]),q=react.useCallback(async r=>{if(e&&t&&l)try{return h(!0),await e.linkAddress(l.id,r)}catch(o){console.error("Error linking address:",o),s(o);}finally{h(!1);}},[e,t,l]);return jsxRuntime.jsx(c.Provider,{value:{authorize:S,isAuthorized:t,profile:l,balances:v,loading:B,loadingPlaceOrder:D,loadingLinkAddress:E,loadingBalances:z,getBalances:w,linkAddress:q,placeOrder:U,orders:T,tokens:F,error:N,loadingAuth:V},children:i})};function ue(){let i=react.useContext(c);if(i===null)throw new Error("useMonerium must be used within a MoneriumProvider");return i}
+var y=react.createContext(null);var F=({children:e,clientId:t="f99e629b-6dca-11ee-8aa6-5273f65ed05b",redirectUrl:r="http://localhost:5173",environment:n="sandbox"})=>{let s=reactQuery.useQueryClient(),[o,f]=react.useState(),[i,u]=react.useState(!1),[a,A]=react.useState(null),[E,b]=react.useState(!0);react.useEffect(()=>{let h=new sdk.MoneriumClient({environment:n,clientId:t,redirectUrl:r});f(h);},[]),react.useEffect(()=>((async()=>{if(o)try{u(await o.getAccess());}catch(p){console.error("Failed to get access:",p);}finally{b(!1);}})(),()=>{o&&o.disconnect();}),[o]);let z=react.useCallback(async h=>{try{o&&await o.authorize(h);}catch(p){console.error("Error during authorization:",p),A(p);}},[o]),v=async()=>{try{o&&await o.revokeAccess();}catch(h){console.error("Error during revoking access:",h),A(h);}finally{s.clear(),u(!1);}};return jsxRuntime.jsx(y.Provider,{value:{sdk:o,authorize:z,isAuthorized:i,isLoading:E,error:a,disconnect:async()=>o?.disconnect(),revokeAccess:async()=>v()},children:e})};var d={getAll:["monerium"],getAuthContext:["monerium","auth-context"],getProfile:e=>["monerium","profile",...e?[e]:[]],getProfiles:["monerium","profiles"],getBalances:e=>["monerium","balances",...e?[e]:[]],getTokens:["monerium","tokens"],getOrder:e=>["monerium","order",e],getOrders:e=>["monerium","orders",...e?[e]:[]],placeOrder:["monerium","place-order"],linkAddress:["monerium","link-address"]};function c(){let e=react.useContext(y);if(e===null)throw new Error("useSdk must be used within a MoneriumProvider");return e?.sdk}function l(){let e=react.useContext(y);if(e===null)throw new Error("useAuth must be used within a MoneriumProvider");return {isAuthorized:e.isAuthorized,authorize:e.authorize,isLoading:e.isLoading,error:e.error,disconnect:e.disconnect,revokeAccess:e.revokeAccess}}function K({query:e}={}){let{isAuthorized:t}=l(),r=c(),{data:n,...s}=reactQuery.useQuery({...e,queryKey:d.getAuthContext,queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!t)throw new Error("User not authorized");return r.getAuthContext()},enabled:!!(r&&t&&(e?.enabled??!0))});return {authContext:n,...s}}function V({profileId:e,query:t}={}){let{isAuthorized:r}=l(),n=c(),{authContext:s}=K(),o=e||s?.defaultProfile,{data:f,...i}=reactQuery.useQuery({...t,queryKey:d.getProfile(o),queryFn:async()=>{if(!n)throw new Error("No SDK instance available");if(!r)throw new Error("User not authorized");if(!o)throw new Error("Profile Id is required");return n.getProfile(o)},enabled:!!(n&&r&&o&&(t?.enabled??!0))});return {profile:f,...i}}function W({query:e}={}){let{isAuthorized:t}=l(),r=c(),{data:n,...s}=reactQuery.useQuery({...e,queryKey:d.getProfiles,queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!t)throw new Error("User not authorized");return r.getProfiles()},enabled:!!(r&&t&&(e?.enabled??!0))});return {profiles:n,...s}}function X({query:e}={}){let t=c(),{isAuthorized:r}=l(),{data:n,...s}=reactQuery.useQuery({...e,queryKey:d.getTokens,queryFn:async()=>{if(!t)throw new Error("No SDK instance available");if(!r)throw new Error("User not authorized");return t.getTokens()},enabled:!!(t&&r&&(e?.enabled??!0))});return {tokens:n,...s}}function Y({profileId:e,query:t}={}){let r=c(),{isAuthorized:n}=l(),{data:s,...o}=reactQuery.useQuery({...t,queryKey:d.getBalances(e),queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");return r.getBalances(e)},enabled:!!(r&&n&&(t?.enabled??!0))});return {balances:s,...o}}function Z({orderId:e,query:t={}}){let r=c(),{isAuthorized:n}=l(),{data:s,...o}=reactQuery.useQuery({...t,queryKey:d.getOrder(e),queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");if(!e)throw new Error("Order id is required");return r.getOrder(e)},enabled:!!(r&&n&&e&&(t.enabled??!0))});return {order:s,...o}}function _({query:e={},...t}={}){let r=c(),{isAuthorized:n}=l(),{data:s,...o}=reactQuery.useQuery({...e,queryKey:d.getOrders(t),queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");return r.getOrders(t)},enabled:!!(r&&n&&(e.enabled??!0))});return {orders:s,...o}}function $({supportingDocument:e,mutation:t}={}){let r=c(),{isAuthorized:n}=l(),s=reactQuery.useQueryClient(),{mutateAsync:o,...f}=reactQuery.useMutation({...t,mutationKey:d.placeOrder,mutationFn:async i=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");let u;if(parseInt(i.amount)>15e3){if(!e)throw new Error("Supporting document is required for orders above 15000");u=(await r.uploadSupportingDocument(e)).id;}let a={...i,documentId:u};return r.placeOrder(a)},onSuccess(i,u,a){s.invalidateQueries({queryKey:d.getOrders()}),t?.onSuccess?.(i,u,a);},onError(i,u,a){throw t?.onError?.(i,u,a),i}});return {placeOrder:o,...f}}function j({profileId:e,mutation:t}){let r=c(),{isAuthorized:n}=l(),s=reactQuery.useQueryClient(),{mutateAsync:o,...f}=reactQuery.useMutation({...t,mutationKey:d.linkAddress,mutationFn:async i=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");return r.linkAddress(e,i)},onSuccess(i,u,a){s.invalidateQueries({queryKey:d.getProfile(e)}),t?.onSuccess?.(i,u,a);},onError(i,u,a){throw t?.onError?.(i,u,a),i}});return {linkAddress:o,...f}}
 
-exports.MoneriumContext = c;
-exports.MoneriumProvider = ae;
-exports.useMonerium = ue;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/provider.tsx","../src/lib/context.tsx","../src/lib/hook.tsx"],"names":["useCallback","useEffect","useState","MoneriumClient","createContext","MoneriumContext","jsx","MoneriumProvider","children","clientId","redirectUrl","environment","monerium","setMonerium","isAuthorized","setIsAuthorized","profile","setProfile","balances","setBalances","loading","setLoading","loadingPlaceOrder","setLoadingPlaceOrder","loadingLinkAddress","setLoadingLinkAddress","loadingBalances","setLoadingBalances","error","setError","orders","setOrders","tokens","setTokens","loadingAuth","setLoadingAuth","sdk","authCtx","getBalances","profileData","tokensData","ordersData","err","authorize","placeOrder","orderDetails","supportingDocument","documentId","newOrderDetails","newOrder","prevOrders","linkAddress","addressDetails","useContext","useMonerium","context"],"mappings":"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","sourcesContent":["import { FC, ReactNode, useCallback, useEffect, useState } from 'react';\n\nimport {\n  Balances,\n  LinkAddress,\n  MoneriumClient,\n  NewOrder,\n  Order,\n  Profile,\n  Token,\n} from '@monerium/sdk';\n\nimport { MoneriumContext } from './context';\n\ninterface MoneriumProviderProps {\n  children: ReactNode;\n  clientId?: string;\n  redirectUrl?: string;\n  environment?: 'sandbox' | 'production';\n}\n\nexport const MoneriumProvider: FC<MoneriumProviderProps> = ({\n  children,\n  clientId = 'f99e629b-6dca-11ee-8aa6-5273f65ed05b',\n  redirectUrl = 'http://localhost:5173',\n  environment = 'sandbox',\n}) => {\n  const [monerium, setMonerium] = useState<MoneriumClient>();\n  const [isAuthorized, setIsAuthorized] = useState<boolean>(false);\n  const [profile, setProfile] = useState<Profile | null>(null);\n  const [balances, setBalances] = useState<Balances[] | null>(null);\n  const [loading, setLoading] = useState(false);\n  const [loadingPlaceOrder, setLoadingPlaceOrder] = useState(false);\n  const [loadingLinkAddress, setLoadingLinkAddress] = useState(false);\n  const [loadingBalances, setLoadingBalances] = useState(false);\n  const [error, setError] = useState<Error | unknown | null>(null);\n  const [orders, setOrders] = useState<Order[]>([]);\n  const [tokens, setTokens] = useState<Token[]>([]);\n  const [loadingAuth, setLoadingAuth] = useState(true);\n\n  // Initialize the SDK\n  useEffect(() => {\n    const sdk = new MoneriumClient({\n      environment: environment,\n      clientId,\n      redirectUrl,\n    });\n    setMonerium(sdk);\n  }, []);\n\n  useEffect(() => {\n    const connect = async () => {\n      if (monerium) {\n        try {\n          setIsAuthorized(await monerium.getAccess());\n        } catch (error) {\n          console.error('Failed to get access:', error);\n        } finally {\n          setLoadingAuth(false);\n        }\n      }\n    };\n\n    connect();\n\n    return () => {\n      if (monerium) {\n        monerium.disconnect();\n      }\n    };\n  }, [monerium]);\n\n  useEffect(() => {\n    const fetchData = async () => {\n      if (monerium && isAuthorized) {\n        try {\n          setLoading(true);\n          const [authCtx] = await Promise.all([\n            monerium.getAuthContext(),\n            getBalances(),\n          ]);\n\n          const [profileData, tokensData] = await Promise.all([\n            monerium.getProfile(authCtx.defaultProfile),\n            monerium.getTokens(),\n          ]);\n\n          const ordersData = await monerium.getOrders();\n\n          setProfile(profileData);\n          setOrders(ordersData);\n          setTokens(tokensData);\n        } catch (err) {\n          console.error('Error fetching data:', err);\n          setError(err);\n        } finally {\n          setLoading(false);\n        }\n      }\n    };\n\n    fetchData();\n  }, [monerium, isAuthorized]);\n\n  const authorize = useCallback(async () => {\n    try {\n      if (monerium) {\n        await monerium.authorize();\n      }\n    } catch (err) {\n      console.error('Error during authorization:', err);\n      setError(err);\n    }\n  }, [monerium]);\n\n  const getBalances = useCallback(async () => {\n    if (monerium && isAuthorized) {\n      try {\n        setLoadingBalances(true);\n        const balances = await monerium.getBalances();\n        setBalances(balances);\n      } catch (err) {\n        console.error('Error getting balances:', err);\n        setError(err);\n      } finally {\n        setLoadingBalances(false);\n      }\n    }\n  }, [monerium, isAuthorized]);\n\n  const placeOrder = useCallback(\n    async (orderDetails: NewOrder, supportingDocument?: File) => {\n      if (monerium && isAuthorized) {\n        try {\n          setLoadingPlaceOrder(true);\n\n          let documentId;\n          if (parseInt(orderDetails.amount) > 15000 && supportingDocument) {\n            const uploadedDocument =\n              await monerium.uploadSupportingDocument(supportingDocument);\n            documentId = uploadedDocument.id;\n          }\n\n          const newOrderDetails = {\n            ...orderDetails,\n            documentId: documentId,\n          };\n\n          const newOrder = await monerium.placeOrder(newOrderDetails);\n          setOrders((prevOrders) => [...prevOrders, newOrder]);\n        } catch (err) {\n          console.error('Error placing order:', err);\n          setError(err);\n        } finally {\n          setLoadingPlaceOrder(false);\n        }\n      }\n    },\n    [monerium, isAuthorized]\n  );\n\n  const linkAddress = useCallback(\n    async (addressDetails: LinkAddress) => {\n      if (monerium && isAuthorized && profile) {\n        try {\n          setLoadingLinkAddress(true);\n          return await monerium.linkAddress(profile.id, addressDetails);\n\n          // Update your state or do something with linkedAddress\n        } catch (err) {\n          console.error('Error linking address:', err);\n          setError(err);\n        } finally {\n          setLoadingLinkAddress(false);\n        }\n      }\n    },\n    [monerium, isAuthorized, profile]\n  );\n\n  //\n\n  return (\n    <MoneriumContext.Provider\n      value={{\n        authorize,\n        isAuthorized,\n        profile,\n        balances,\n        loading,\n        loadingPlaceOrder,\n        loadingLinkAddress,\n        loadingBalances,\n        getBalances,\n        linkAddress,\n        placeOrder,\n        orders,\n        tokens,\n        error,\n        loadingAuth,\n      }}\n    >\n      {children}\n    </MoneriumContext.Provider>\n  );\n};\n","import { createContext } from 'react';\n\nimport {\n  Balances,\n  LinkAddress,\n  NewOrder,\n  Order,\n  Profile,\n  Token,\n} from '@monerium/sdk';\n\nexport interface MoneriumContextValue {\n  authorize: () => Promise<void>;\n  isAuthorized: boolean;\n  profile: Profile | null;\n  balances: Balances[] | null;\n  loading: boolean;\n  loadingPlaceOrder: boolean;\n  loadingLinkAddress: boolean;\n  loadingBalances: boolean;\n  getBalances: () => Promise<void>;\n  linkAddress: (addressDetails: LinkAddress) => Promise<unknown>;\n  placeOrder: (\n    orderDetails: NewOrder,\n    supportingDocument?: File\n  ) => Promise<void>;\n  orders: Order[];\n  tokens: Token[];\n  error: unknown;\n  /** Is still checking if there is an active session */\n  loadingAuth: boolean;\n}\n\nexport const MoneriumContext = createContext<MoneriumContextValue | null>(null);\n","import { useContext } from 'react';\n\nimport { MoneriumContext, MoneriumContextValue } from './context';\n\nexport function useMonerium(): MoneriumContextValue {\n  const context = useContext(MoneriumContext);\n\n  if (context === null) {\n    throw new Error('useMonerium must be used within a MoneriumProvider');\n  }\n  return context;\n}\n"]}
+exports.MoneriumContext = y;
+exports.MoneriumProvider = F;
+exports.keys = d;
+exports.useAuth = l;
+exports.useAuthContext = K;
+exports.useBalances = Y;
+exports.useLinkAddress = j;
+exports.useOrder = Z;
+exports.useOrders = _;
+exports.usePlaceOrder = $;
+exports.useProfile = V;
+exports.useProfiles = W;
+exports.useTokens = X;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/context.tsx","../src/lib/provider.tsx","../src/lib/hooks.tsx"],"names":["MoneriumContext","createContext","MoneriumProvider","children","clientId","redirectUrl","environment","queryClient","useQueryClient","sdk","setSdk","useState","isAuthorized","setIsAuthorized","error","setError","loadingAuth","setLoadingAuth","useEffect","sdkInstance","MoneriumClient","authorize","useCallback","params","err","revokeAccess","jsx","keys","profileId","orderId","filter","useSdk","context","useContext","useAuth","useAuthContext","query","data","rest","useQuery","useProfile","authContext","profileIdToUse","useProfiles","useTokens","useBalances","useOrder","useOrders","filters","usePlaceOrder","supportingDocument","mutation","mutateAsync","useMutation","body","documentId","newBody","variables","vars","useLinkAddress"],"mappings":"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","file":"index.js","sourcesContent":["import { createContext } from 'react';\n\nimport { SdkInstance, UseAuthReturn } from './types';\n\nexport const MoneriumContext = createContext<\n  (UseAuthReturn & SdkInstance) | null\n>(null);\n","import { ReactNode, useCallback, useEffect, useState } from 'react';\nimport { useQueryClient } from '@tanstack/react-query';\n\nimport { MoneriumClient } from '@monerium/sdk';\n\nimport { MoneriumContext } from './context';\nimport { AuthorizeParams } from './types';\n\n/**\n * Place this provider at the root of your application.\n * @group Provider\n * @param params\n * @param params.children - Rest of the application.\n * @param params.clientId - Monerium auth flow client id.\n * @param params.redirectUrl - Monerium auth flow redirect url.\n * @param params.environment - Monerium environment.\n * @returns\n */\nexport const MoneriumProvider = ({\n  children,\n  clientId = 'f99e629b-6dca-11ee-8aa6-5273f65ed05b',\n  redirectUrl = 'http://localhost:5173',\n  environment = 'sandbox',\n}: {\n  children: ReactNode;\n  clientId?: string;\n  redirectUrl?: string;\n  environment?: 'sandbox' | 'production';\n}) => {\n  const queryClient = useQueryClient();\n\n  const [sdk, setSdk] = useState<MoneriumClient>();\n  const [isAuthorized, setIsAuthorized] = useState<boolean>(false);\n  const [error, setError] = useState<Error | unknown | null>(null);\n  const [loadingAuth, setLoadingAuth] = useState(true);\n\n  // Initialize the SDK\n  useEffect(() => {\n    const sdkInstance = new MoneriumClient({\n      environment: environment,\n      clientId,\n      redirectUrl,\n    });\n    setSdk(sdkInstance);\n  }, []);\n\n  useEffect(() => {\n    const connect = async () => {\n      if (sdk) {\n        try {\n          setIsAuthorized(await sdk.getAccess());\n        } catch (error) {\n          console.error('Failed to get access:', error);\n        } finally {\n          setLoadingAuth(false);\n        }\n      }\n    };\n\n    connect();\n\n    return () => {\n      if (sdk) {\n        sdk.disconnect();\n      }\n    };\n  }, [sdk]);\n\n  const authorize = useCallback(\n    async (params?: AuthorizeParams) => {\n      try {\n        if (sdk) {\n          await sdk.authorize(params);\n        }\n      } catch (err) {\n        console.error('Error during authorization:', err);\n        setError(err);\n      }\n    },\n    [sdk]\n  );\n\n  const revokeAccess = async () => {\n    try {\n      if (sdk) {\n        await sdk.revokeAccess();\n      }\n    } catch (err) {\n      console.error('Error during revoking access:', err);\n      setError(err);\n    } finally {\n      queryClient.clear();\n      setIsAuthorized(false);\n    }\n  };\n\n  return (\n    <MoneriumContext.Provider\n      value={{\n        sdk,\n        authorize,\n        isAuthorized,\n        isLoading: loadingAuth,\n        error,\n        disconnect: async () => sdk?.disconnect(),\n        revokeAccess: async () => revokeAccess(),\n      }}\n    >\n      {children}\n    </MoneriumContext.Provider>\n  );\n};\n","import { useContext } from 'react';\nimport { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';\n\nimport MoneriumClient, {\n  AuthContext,\n  Balances,\n  LinkAddress,\n  LinkedAddress,\n  NewOrder,\n  Order,\n  OrderState,\n  Profile,\n  Token,\n} from '@monerium/sdk';\n\nimport { MoneriumContext } from './context';\nimport {\n  MutationOptions,\n  MutationResult,\n  QueryOptions,\n  QueryResult,\n  UseAuthReturn,\n} from './types';\n\n/**\n * @internal\n * Query keys\n * */\nexport const keys = {\n  getAll: ['monerium'],\n  getAuthContext: ['monerium', 'auth-context'],\n  getProfile: (profileId: string) => [\n    'monerium',\n    'profile',\n    ...(profileId ? [profileId] : []),\n  ],\n  getProfiles: ['monerium', 'profiles'],\n  getBalances: (profileId?: string) => [\n    'monerium',\n    'balances',\n    ...(profileId ? [profileId] : []),\n  ],\n  getTokens: ['monerium', 'tokens'],\n  getOrder: (orderId: string) => ['monerium', 'order', orderId],\n  getOrders: (filter?: unknown) => [\n    'monerium',\n    'orders',\n    ...(filter ? [filter] : []),\n  ],\n  placeOrder: ['monerium', 'place-order'],\n  linkAddress: ['monerium', 'link-address'],\n};\n\n/** Internal hook to use SDK */\nfunction useSdk(): MoneriumClient | undefined {\n  const context = useContext(MoneriumContext);\n\n  if (context === null) {\n    throw new Error('useSdk must be used within a MoneriumProvider');\n  }\n  return context?.sdk;\n}\n\n/**\n * # Redirect to the Monerium auth flow.\n * @group Hooks\n * @example\n * ```ts\n * const { authorize, isAuthorized, isLoading, error } = useAuth();\n *\n * authorize(); // Redirects to the Monerium auth flow.\n *\n * // To opt-in to automated wallet linking, pass the address, signature and chainId.\n * authorize({ address, signature, chainId }).\n * ```\n *\n * @returns {UseAuthReturn}\n * - `authorize`  - Redirects to the Monerium auth flow.\n * - `isAuthorized` - Whether the user is authorized.\n * - `isLoading` - Whether the auth flow is loading.\n * - `error` - Error message if the auth flow fails.\n * - `disconnect` - Disconnect the user.\n * - `revokeAccess` - Revoke the user's access.\n */\nexport function useAuth(): UseAuthReturn {\n  const context = useContext(MoneriumContext);\n\n  if (context === null) {\n    throw new Error('useAuth must be used within a MoneriumProvider');\n  }\n  return {\n    isAuthorized: context.isAuthorized,\n    authorize: context.authorize,\n    isLoading: context.isLoading,\n    error: context.error,\n    disconnect: context.disconnect,\n    revokeAccess: context.revokeAccess,\n  };\n}\n\n/**\n * # Get the authentication context.\n * @group Hooks\n *\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<AuthContext>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    authContext, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useAuthContext();\n * ```\n *\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/auth-context)\n *\n * [AuthContext interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/AuthContext.md)\n */\nexport function useAuthContext({\n  query,\n}: {\n  query?: QueryOptions<AuthContext>;\n} = {}): QueryResult<'authContext', AuthContext> {\n  const { isAuthorized } = useAuth();\n  const sdk = useSdk();\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getAuthContext,\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getAuthContext();\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    authContext: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get single profile\n * If no `profileId` is provided, the default profile is used.\n * @group Hooks\n * @param {Object} params\n * @param {string} [params.profileId] The id of the profile.\n * @param {QueryOptions<Profile>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    profile, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useProfile();\n * ```\n\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profile)\n *\n * [Profile interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Profile.md)\n */\nexport function useProfile({\n  profileId,\n  query,\n}: {\n  profileId?: string;\n  query?: QueryOptions<Profile>;\n} = {}): QueryResult<'profile', Profile> {\n  const { isAuthorized } = useAuth();\n  const sdk = useSdk();\n  const { authContext } = useAuthContext();\n\n  const profileIdToUse = profileId || (authContext?.defaultProfile as string);\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getProfile(profileIdToUse),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      if (!profileIdToUse) {\n        throw new Error('Profile Id is required');\n      }\n\n      return sdk.getProfile(profileIdToUse);\n    },\n    enabled: Boolean(\n      sdk && isAuthorized && profileIdToUse && (query?.enabled ?? true)\n    ),\n  });\n  return {\n    profile: data,\n    ...rest,\n  };\n}\n/**\n * # Get profiles\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<Profile[]>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    profiles, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useProfiles();\n * ```\n\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profiles)\n *\n * [Profile interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Profile.md)\n */\nexport function useProfiles({\n  query,\n}: {\n  query?: QueryOptions<Profile[]>;\n} = {}): QueryResult<'profiles', Profile[]> {\n  const { isAuthorized } = useAuth();\n  const sdk = useSdk();\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getProfiles,\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getProfiles();\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    profiles: data,\n    ...rest,\n  };\n}\n/**\n * # Get tokens\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<Token[]>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    tokens, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useTokens();\n * ```\n\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/tokens)\n *\n * [Token interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Token.md)\n */\nexport function useTokens({\n  query,\n}: { query?: QueryOptions<Token[]> } = {}): QueryResult<'tokens', Token[]> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getTokens,\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getTokens();\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    tokens: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get balances\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<Balances[]>} [params.profileId] Fetch balances for a specific profile.\n * @param {QueryOptions<Balances[]>} [params.query] {@inheritDoc QueryOptions}\n\n * @example\n * ```ts\n * const {\n *    balances, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useBalances();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profile-balances)\n *\n * [Balances interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Balances.md)\n */\nexport function useBalances({\n  profileId,\n  query,\n}: {\n  profileId?: string;\n  query?: QueryOptions<Balances[]>;\n} = {}): QueryResult<'balances', Balances[]> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getBalances(profileId),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getBalances(profileId);\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    balances: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get single order\n * @group Hooks\n * @param {Object} params\n * @param {Object} params.orderId The id of the order.\n * @param {QueryOptions<Order>} [params.query] {@inheritDoc QueryOptions}\n * @example\n * ```ts\n * const {\n *    order, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useOrder();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/order)\n *\n * [Order interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Order.md)\n */\nexport function useOrder({\n  orderId,\n  query = {},\n}: {\n  orderId: string;\n  query?: QueryOptions<Order>;\n}): QueryResult<'order', Order> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getOrder(orderId),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      if (!orderId) {\n        throw new Error('Order id is required');\n      }\n\n      return sdk.getOrder(orderId);\n    },\n    enabled: Boolean(sdk && isAuthorized && orderId && (query.enabled ?? true)),\n  });\n  return {\n    order: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get orders\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {Object} [params.address] Filter based on the blockchain address associated with the order.\n * @param {Object} [params.memo] Filter by the payment memo/reference..\n * @param {Object} [params.profile] Filter based on the profile ID associated with the order.\n * @param {Object} [params.state] Filter based on the state of the order.\n * @param {Object} [params.txHash] Filter based on the blockchain transaction hash.\n * @param {QueryOptions<Order[]>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    orders, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useOrders();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/orders)\n *\n * [Order interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Order.md)\n */\nexport function useOrders({\n  query = {},\n  ...filters\n}: {\n  query?: QueryOptions<Order[]>;\n  address?: string;\n  txHash?: string;\n  profile?: string;\n  memo?: string;\n  state?: OrderState;\n} = {}): QueryResult<'orders', Order[]> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getOrders(filters),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n\n      return sdk.getOrders(filters);\n    },\n    enabled: Boolean(sdk && isAuthorized && (query.enabled ?? true)),\n  });\n  return {\n    orders: data,\n    ...rest,\n  };\n}\n\n/**\n * # Place an order.\n * When the order has been placed, the orders query will be invalidated and re-fetched.\n *\n * If the order amount is above 15000, a supporting document is required.\n * @group Hooks\n * @param param\n * @param {File} param.supportingDocument Supporting document file.\n * @param {Object} param.mutation {@inheritDoc MutationOptions}\n *\n * @example\n * ```ts\n * const {\n *    placeOrder, // useMutation's `mutateAsync` property\n *    isPending,\n *    isError,\n *    error,\n *    status,\n *    ...moreUseMutationResults\n * } = usePlaceOrder();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/post-orders)\n *\n * [NewOrder type](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/type-aliases/NewOrder.md)\n */\n\nexport function usePlaceOrder({\n  supportingDocument,\n  mutation,\n}: {\n  supportingDocument?: File;\n  mutation?: MutationOptions<Order, Error, NewOrder>;\n} = {}): MutationResult<'placeOrder', Order, Error, NewOrder> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const queryClient = useQueryClient();\n\n  const { mutateAsync, ...rest } = useMutation({\n    ...mutation,\n    mutationKey: keys.placeOrder,\n    mutationFn: async (body: NewOrder) => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      let documentId;\n      if (parseInt(body.amount) > 15000) {\n        if (!supportingDocument) {\n          throw new Error(\n            'Supporting document is required for orders above 15000'\n          );\n        }\n        const uploadedDocument =\n          await sdk.uploadSupportingDocument(supportingDocument);\n        documentId = uploadedDocument.id;\n      }\n\n      const newBody = {\n        ...body,\n        documentId: documentId,\n      };\n\n      return sdk.placeOrder(newBody);\n    },\n    onSuccess(data, variables, context) {\n      // Refetch all orders on success.\n      queryClient.invalidateQueries({\n        queryKey: keys.getOrders(),\n      });\n      // Allow the caller to add custom logic on success.\n      mutation?.onSuccess?.(data, variables, context);\n    },\n    onError(error, vars, context) {\n      // Allow the caller to add custom logic on error.\n      mutation?.onError?.(error, vars, context);\n      throw error;\n    },\n  });\n  return {\n    placeOrder: mutateAsync,\n    ...rest,\n  };\n}\n/**\n * # Add address to profile.\n * When the address has been linked, the relevant profile query will be invalidated and re-fetched.\n *\n * @group Hooks\n * @param param\n * @param {File} param.profileId Which profile to link the address.\n * @param {Object} param.mutation {@inheritDoc MutationOptions}\n *\n * @example\n * ```ts\n * const {\n *    linkAddress, // useMutation's `mutateAsync` property\n *    isPending,\n *    isError,\n *    error,\n *    status,\n *    ...moreUseMutationResults\n * } = useLinkAddress();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profile-addresses)\n *\n * [LinkAddress interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/LinkAddress.md)\n */\nexport function useLinkAddress({\n  profileId,\n  mutation,\n}: {\n  profileId: string;\n  mutation?: MutationOptions<LinkedAddress, Error, LinkAddress>;\n}): MutationResult<'linkAddress', LinkedAddress, Error, LinkAddress> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const queryClient = useQueryClient();\n\n  const { mutateAsync, ...rest } = useMutation({\n    ...mutation,\n    mutationKey: keys.linkAddress,\n    mutationFn: async (body: LinkAddress) => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.linkAddress(profileId, body);\n    },\n    onSuccess(data, variables, context) {\n      // Refetch all orders on success.\n      queryClient.invalidateQueries({\n        queryKey: keys.getProfile(profileId),\n      });\n      // Allow the caller to add custom logic on success.\n      mutation?.onSuccess?.(data, variables, context);\n    },\n    onError(error, vars, context) {\n      // Allow the caller to add custom logic on error.\n      mutation?.onError?.(error, vars, context);\n      throw error;\n    },\n  });\n  return {\n    linkAddress: mutateAsync,\n    ...rest,\n  };\n}\n"]}

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import { createContext, useState, useEffect, useCallback, useContext } from 'react';
+import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
 import { MoneriumClient } from '@monerium/sdk';
 import { jsx } from 'react/jsx-runtime';
 
-var c=createContext(null);var ae=({children:i,clientId:A="f99e629b-6dca-11ee-8aa6-5273f65ed05b",redirectUrl:O="http://localhost:5173",environment:b="sandbox"})=>{let[e,y]=useState(),[t,C]=useState(!1),[l,M]=useState(null),[v,L]=useState(null),[B,g]=useState(!1),[D,p]=useState(!1),[E,h]=useState(!1),[z,k]=useState(!1),[N,s]=useState(null),[T,P]=useState([]),[F,I]=useState([]),[V,R]=useState(!0);useEffect(()=>{let r=new MoneriumClient({environment:b,clientId:A,redirectUrl:O});y(r);},[]),useEffect(()=>((async()=>{if(e)try{C(await e.getAccess());}catch(o){console.error("Failed to get access:",o);}finally{R(!1);}})(),()=>{e&&e.disconnect();}),[e]),useEffect(()=>{(async()=>{if(e&&t)try{g(!0);let[o]=await Promise.all([e.getAuthContext(),w()]),[a,u]=await Promise.all([e.getProfile(o.defaultProfile),e.getTokens()]),f=await e.getOrders();M(a),P(f),I(u);}catch(o){console.error("Error fetching data:",o),s(o);}finally{g(!1);}})();},[e,t]);let S=useCallback(async()=>{try{e&&await e.authorize();}catch(r){console.error("Error during authorization:",r),s(r);}},[e]),w=useCallback(async()=>{if(e&&t)try{k(!0);let r=await e.getBalances();L(r);}catch(r){console.error("Error getting balances:",r),s(r);}finally{k(!1);}},[e,t]),U=useCallback(async(r,o)=>{if(e&&t)try{p(!0);let a;parseInt(r.amount)>15e3&&o&&(a=(await e.uploadSupportingDocument(o)).id);let u={...r,documentId:a},f=await e.placeOrder(u);P(x=>[...x,f]);}catch(a){console.error("Error placing order:",a),s(a);}finally{p(!1);}},[e,t]),q=useCallback(async r=>{if(e&&t&&l)try{return h(!0),await e.linkAddress(l.id,r)}catch(o){console.error("Error linking address:",o),s(o);}finally{h(!1);}},[e,t,l]);return jsx(c.Provider,{value:{authorize:S,isAuthorized:t,profile:l,balances:v,loading:B,loadingPlaceOrder:D,loadingLinkAddress:E,loadingBalances:z,getBalances:w,linkAddress:q,placeOrder:U,orders:T,tokens:F,error:N,loadingAuth:V},children:i})};function ue(){let i=useContext(c);if(i===null)throw new Error("useMonerium must be used within a MoneriumProvider");return i}
+var y=createContext(null);var F=({children:e,clientId:t="f99e629b-6dca-11ee-8aa6-5273f65ed05b",redirectUrl:r="http://localhost:5173",environment:n="sandbox"})=>{let s=useQueryClient(),[o,f]=useState(),[i,u]=useState(!1),[a,A]=useState(null),[E,b]=useState(!0);useEffect(()=>{let h=new MoneriumClient({environment:n,clientId:t,redirectUrl:r});f(h);},[]),useEffect(()=>((async()=>{if(o)try{u(await o.getAccess());}catch(p){console.error("Failed to get access:",p);}finally{b(!1);}})(),()=>{o&&o.disconnect();}),[o]);let z=useCallback(async h=>{try{o&&await o.authorize(h);}catch(p){console.error("Error during authorization:",p),A(p);}},[o]),v=async()=>{try{o&&await o.revokeAccess();}catch(h){console.error("Error during revoking access:",h),A(h);}finally{s.clear(),u(!1);}};return jsx(y.Provider,{value:{sdk:o,authorize:z,isAuthorized:i,isLoading:E,error:a,disconnect:async()=>o?.disconnect(),revokeAccess:async()=>v()},children:e})};var d={getAll:["monerium"],getAuthContext:["monerium","auth-context"],getProfile:e=>["monerium","profile",...e?[e]:[]],getProfiles:["monerium","profiles"],getBalances:e=>["monerium","balances",...e?[e]:[]],getTokens:["monerium","tokens"],getOrder:e=>["monerium","order",e],getOrders:e=>["monerium","orders",...e?[e]:[]],placeOrder:["monerium","place-order"],linkAddress:["monerium","link-address"]};function c(){let e=useContext(y);if(e===null)throw new Error("useSdk must be used within a MoneriumProvider");return e?.sdk}function l(){let e=useContext(y);if(e===null)throw new Error("useAuth must be used within a MoneriumProvider");return {isAuthorized:e.isAuthorized,authorize:e.authorize,isLoading:e.isLoading,error:e.error,disconnect:e.disconnect,revokeAccess:e.revokeAccess}}function K({query:e}={}){let{isAuthorized:t}=l(),r=c(),{data:n,...s}=useQuery({...e,queryKey:d.getAuthContext,queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!t)throw new Error("User not authorized");return r.getAuthContext()},enabled:!!(r&&t&&(e?.enabled??!0))});return {authContext:n,...s}}function V({profileId:e,query:t}={}){let{isAuthorized:r}=l(),n=c(),{authContext:s}=K(),o=e||s?.defaultProfile,{data:f,...i}=useQuery({...t,queryKey:d.getProfile(o),queryFn:async()=>{if(!n)throw new Error("No SDK instance available");if(!r)throw new Error("User not authorized");if(!o)throw new Error("Profile Id is required");return n.getProfile(o)},enabled:!!(n&&r&&o&&(t?.enabled??!0))});return {profile:f,...i}}function W({query:e}={}){let{isAuthorized:t}=l(),r=c(),{data:n,...s}=useQuery({...e,queryKey:d.getProfiles,queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!t)throw new Error("User not authorized");return r.getProfiles()},enabled:!!(r&&t&&(e?.enabled??!0))});return {profiles:n,...s}}function X({query:e}={}){let t=c(),{isAuthorized:r}=l(),{data:n,...s}=useQuery({...e,queryKey:d.getTokens,queryFn:async()=>{if(!t)throw new Error("No SDK instance available");if(!r)throw new Error("User not authorized");return t.getTokens()},enabled:!!(t&&r&&(e?.enabled??!0))});return {tokens:n,...s}}function Y({profileId:e,query:t}={}){let r=c(),{isAuthorized:n}=l(),{data:s,...o}=useQuery({...t,queryKey:d.getBalances(e),queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");return r.getBalances(e)},enabled:!!(r&&n&&(t?.enabled??!0))});return {balances:s,...o}}function Z({orderId:e,query:t={}}){let r=c(),{isAuthorized:n}=l(),{data:s,...o}=useQuery({...t,queryKey:d.getOrder(e),queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");if(!e)throw new Error("Order id is required");return r.getOrder(e)},enabled:!!(r&&n&&e&&(t.enabled??!0))});return {order:s,...o}}function _({query:e={},...t}={}){let r=c(),{isAuthorized:n}=l(),{data:s,...o}=useQuery({...e,queryKey:d.getOrders(t),queryFn:async()=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");return r.getOrders(t)},enabled:!!(r&&n&&(e.enabled??!0))});return {orders:s,...o}}function $({supportingDocument:e,mutation:t}={}){let r=c(),{isAuthorized:n}=l(),s=useQueryClient(),{mutateAsync:o,...f}=useMutation({...t,mutationKey:d.placeOrder,mutationFn:async i=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");let u;if(parseInt(i.amount)>15e3){if(!e)throw new Error("Supporting document is required for orders above 15000");u=(await r.uploadSupportingDocument(e)).id;}let a={...i,documentId:u};return r.placeOrder(a)},onSuccess(i,u,a){s.invalidateQueries({queryKey:d.getOrders()}),t?.onSuccess?.(i,u,a);},onError(i,u,a){throw t?.onError?.(i,u,a),i}});return {placeOrder:o,...f}}function j({profileId:e,mutation:t}){let r=c(),{isAuthorized:n}=l(),s=useQueryClient(),{mutateAsync:o,...f}=useMutation({...t,mutationKey:d.linkAddress,mutationFn:async i=>{if(!r)throw new Error("No SDK instance available");if(!n)throw new Error("User not authorized");return r.linkAddress(e,i)},onSuccess(i,u,a){s.invalidateQueries({queryKey:d.getProfile(e)}),t?.onSuccess?.(i,u,a);},onError(i,u,a){throw t?.onError?.(i,u,a),i}});return {linkAddress:o,...f}}
 
-export { c as MoneriumContext, ae as MoneriumProvider, ue as useMonerium };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/provider.tsx","../src/lib/context.tsx","../src/lib/hook.tsx"],"names":["useCallback","useEffect","useState","MoneriumClient","createContext","MoneriumContext","jsx","MoneriumProvider","children","clientId","redirectUrl","environment","monerium","setMonerium","isAuthorized","setIsAuthorized","profile","setProfile","balances","setBalances","loading","setLoading","loadingPlaceOrder","setLoadingPlaceOrder","loadingLinkAddress","setLoadingLinkAddress","loadingBalances","setLoadingBalances","error","setError","orders","setOrders","tokens","setTokens","loadingAuth","setLoadingAuth","sdk","authCtx","getBalances","profileData","tokensData","ordersData","err","authorize","placeOrder","orderDetails","supportingDocument","documentId","newOrderDetails","newOrder","prevOrders","linkAddress","addressDetails","useContext","useMonerium","context"],"mappings":"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","sourcesContent":["import { FC, ReactNode, useCallback, useEffect, useState } from 'react';\n\nimport {\n  Balances,\n  LinkAddress,\n  MoneriumClient,\n  NewOrder,\n  Order,\n  Profile,\n  Token,\n} from '@monerium/sdk';\n\nimport { MoneriumContext } from './context';\n\ninterface MoneriumProviderProps {\n  children: ReactNode;\n  clientId?: string;\n  redirectUrl?: string;\n  environment?: 'sandbox' | 'production';\n}\n\nexport const MoneriumProvider: FC<MoneriumProviderProps> = ({\n  children,\n  clientId = 'f99e629b-6dca-11ee-8aa6-5273f65ed05b',\n  redirectUrl = 'http://localhost:5173',\n  environment = 'sandbox',\n}) => {\n  const [monerium, setMonerium] = useState<MoneriumClient>();\n  const [isAuthorized, setIsAuthorized] = useState<boolean>(false);\n  const [profile, setProfile] = useState<Profile | null>(null);\n  const [balances, setBalances] = useState<Balances[] | null>(null);\n  const [loading, setLoading] = useState(false);\n  const [loadingPlaceOrder, setLoadingPlaceOrder] = useState(false);\n  const [loadingLinkAddress, setLoadingLinkAddress] = useState(false);\n  const [loadingBalances, setLoadingBalances] = useState(false);\n  const [error, setError] = useState<Error | unknown | null>(null);\n  const [orders, setOrders] = useState<Order[]>([]);\n  const [tokens, setTokens] = useState<Token[]>([]);\n  const [loadingAuth, setLoadingAuth] = useState(true);\n\n  // Initialize the SDK\n  useEffect(() => {\n    const sdk = new MoneriumClient({\n      environment: environment,\n      clientId,\n      redirectUrl,\n    });\n    setMonerium(sdk);\n  }, []);\n\n  useEffect(() => {\n    const connect = async () => {\n      if (monerium) {\n        try {\n          setIsAuthorized(await monerium.getAccess());\n        } catch (error) {\n          console.error('Failed to get access:', error);\n        } finally {\n          setLoadingAuth(false);\n        }\n      }\n    };\n\n    connect();\n\n    return () => {\n      if (monerium) {\n        monerium.disconnect();\n      }\n    };\n  }, [monerium]);\n\n  useEffect(() => {\n    const fetchData = async () => {\n      if (monerium && isAuthorized) {\n        try {\n          setLoading(true);\n          const [authCtx] = await Promise.all([\n            monerium.getAuthContext(),\n            getBalances(),\n          ]);\n\n          const [profileData, tokensData] = await Promise.all([\n            monerium.getProfile(authCtx.defaultProfile),\n            monerium.getTokens(),\n          ]);\n\n          const ordersData = await monerium.getOrders();\n\n          setProfile(profileData);\n          setOrders(ordersData);\n          setTokens(tokensData);\n        } catch (err) {\n          console.error('Error fetching data:', err);\n          setError(err);\n        } finally {\n          setLoading(false);\n        }\n      }\n    };\n\n    fetchData();\n  }, [monerium, isAuthorized]);\n\n  const authorize = useCallback(async () => {\n    try {\n      if (monerium) {\n        await monerium.authorize();\n      }\n    } catch (err) {\n      console.error('Error during authorization:', err);\n      setError(err);\n    }\n  }, [monerium]);\n\n  const getBalances = useCallback(async () => {\n    if (monerium && isAuthorized) {\n      try {\n        setLoadingBalances(true);\n        const balances = await monerium.getBalances();\n        setBalances(balances);\n      } catch (err) {\n        console.error('Error getting balances:', err);\n        setError(err);\n      } finally {\n        setLoadingBalances(false);\n      }\n    }\n  }, [monerium, isAuthorized]);\n\n  const placeOrder = useCallback(\n    async (orderDetails: NewOrder, supportingDocument?: File) => {\n      if (monerium && isAuthorized) {\n        try {\n          setLoadingPlaceOrder(true);\n\n          let documentId;\n          if (parseInt(orderDetails.amount) > 15000 && supportingDocument) {\n            const uploadedDocument =\n              await monerium.uploadSupportingDocument(supportingDocument);\n            documentId = uploadedDocument.id;\n          }\n\n          const newOrderDetails = {\n            ...orderDetails,\n            documentId: documentId,\n          };\n\n          const newOrder = await monerium.placeOrder(newOrderDetails);\n          setOrders((prevOrders) => [...prevOrders, newOrder]);\n        } catch (err) {\n          console.error('Error placing order:', err);\n          setError(err);\n        } finally {\n          setLoadingPlaceOrder(false);\n        }\n      }\n    },\n    [monerium, isAuthorized]\n  );\n\n  const linkAddress = useCallback(\n    async (addressDetails: LinkAddress) => {\n      if (monerium && isAuthorized && profile) {\n        try {\n          setLoadingLinkAddress(true);\n          return await monerium.linkAddress(profile.id, addressDetails);\n\n          // Update your state or do something with linkedAddress\n        } catch (err) {\n          console.error('Error linking address:', err);\n          setError(err);\n        } finally {\n          setLoadingLinkAddress(false);\n        }\n      }\n    },\n    [monerium, isAuthorized, profile]\n  );\n\n  //\n\n  return (\n    <MoneriumContext.Provider\n      value={{\n        authorize,\n        isAuthorized,\n        profile,\n        balances,\n        loading,\n        loadingPlaceOrder,\n        loadingLinkAddress,\n        loadingBalances,\n        getBalances,\n        linkAddress,\n        placeOrder,\n        orders,\n        tokens,\n        error,\n        loadingAuth,\n      }}\n    >\n      {children}\n    </MoneriumContext.Provider>\n  );\n};\n","import { createContext } from 'react';\n\nimport {\n  Balances,\n  LinkAddress,\n  NewOrder,\n  Order,\n  Profile,\n  Token,\n} from '@monerium/sdk';\n\nexport interface MoneriumContextValue {\n  authorize: () => Promise<void>;\n  isAuthorized: boolean;\n  profile: Profile | null;\n  balances: Balances[] | null;\n  loading: boolean;\n  loadingPlaceOrder: boolean;\n  loadingLinkAddress: boolean;\n  loadingBalances: boolean;\n  getBalances: () => Promise<void>;\n  linkAddress: (addressDetails: LinkAddress) => Promise<unknown>;\n  placeOrder: (\n    orderDetails: NewOrder,\n    supportingDocument?: File\n  ) => Promise<void>;\n  orders: Order[];\n  tokens: Token[];\n  error: unknown;\n  /** Is still checking if there is an active session */\n  loadingAuth: boolean;\n}\n\nexport const MoneriumContext = createContext<MoneriumContextValue | null>(null);\n","import { useContext } from 'react';\n\nimport { MoneriumContext, MoneriumContextValue } from './context';\n\nexport function useMonerium(): MoneriumContextValue {\n  const context = useContext(MoneriumContext);\n\n  if (context === null) {\n    throw new Error('useMonerium must be used within a MoneriumProvider');\n  }\n  return context;\n}\n"]}
+export { y as MoneriumContext, F as MoneriumProvider, d as keys, l as useAuth, K as useAuthContext, Y as useBalances, j as useLinkAddress, Z as useOrder, _ as useOrders, $ as usePlaceOrder, V as useProfile, W as useProfiles, X as useTokens };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/context.tsx","../src/lib/provider.tsx","../src/lib/hooks.tsx"],"names":["MoneriumContext","createContext","MoneriumProvider","children","clientId","redirectUrl","environment","queryClient","useQueryClient","sdk","setSdk","useState","isAuthorized","setIsAuthorized","error","setError","loadingAuth","setLoadingAuth","useEffect","sdkInstance","MoneriumClient","authorize","useCallback","params","err","revokeAccess","jsx","keys","profileId","orderId","filter","useSdk","context","useContext","useAuth","useAuthContext","query","data","rest","useQuery","useProfile","authContext","profileIdToUse","useProfiles","useTokens","useBalances","useOrder","useOrders","filters","usePlaceOrder","supportingDocument","mutation","mutateAsync","useMutation","body","documentId","newBody","variables","vars","useLinkAddress"],"mappings":";;;;;AAIO,IAAMA,CAAkBC,CAAAA,aAAAA,CAE7B,IAAI,MCYOC,CAAmB,CAAA,CAAC,CAC/B,QAAA,CAAAC,EACA,QAAAC,CAAAA,CAAAA,CAAW,sCACX,CAAA,WAAA,CAAAC,CAAc,CAAA,uBAAA,CACd,WAAAC,CAAAA,CAAAA,CAAc,SAChB,CAKM,GAAA,CACJ,IAAMC,CAAAA,CAAcC,cAAe,EAAA,CAE7B,CAACC,CAAAA,CAAKC,CAAM,CAAIC,CAAAA,QAAAA,EAChB,CAAA,CAACC,CAAcC,CAAAA,CAAe,CAAIF,CAAAA,QAAAA,CAAkB,EAAK,CACzD,CAAA,CAACG,CAAOC,CAAAA,CAAQ,EAAIJ,QAAiC,CAAA,IAAI,CACzD,CAAA,CAACK,EAAaC,CAAc,CAAA,CAAIN,QAAS,CAAA,CAAA,CAAI,CAGnDO,CAAAA,SAAAA,CAAU,IAAM,CACd,IAAMC,CAAc,CAAA,IAAIC,cAAe,CAAA,CACrC,WAAad,CAAAA,CAAAA,CACb,QAAAF,CAAAA,CAAAA,CACA,YAAAC,CACF,CAAC,CACDK,CAAAA,CAAAA,CAAOS,CAAW,EACpB,CAAG,CAAA,EAAE,CAELD,CAAAA,SAAAA,CAAU,KACQ,CAAA,SAAY,CAC1B,GAAIT,CAAAA,CACF,GAAI,CACFI,EAAgB,MAAMJ,CAAAA,CAAI,SAAU,EAAC,EACvC,CAAA,MAASK,CAAO,CAAA,CACd,QAAQ,KAAM,CAAA,uBAAA,CAAyBA,CAAK,EAC9C,QAAE,CACAG,CAAAA,CAAe,CAAK,CAAA,EACtB,CAEJ,CAEQ,GAAA,CAED,IAAM,CACPR,CACFA,EAAAA,CAAAA,CAAI,UAAW,GAEnB,GACC,CAACA,CAAG,CAAC,CAAA,CAER,IAAMY,CAAYC,CAAAA,WAAAA,CAChB,MAAOC,CAAAA,EAA6B,CAClC,GAAI,CACEd,CACF,EAAA,MAAMA,CAAI,CAAA,SAAA,CAAUc,CAAM,EAE9B,OAASC,CAAK,CAAA,CACZ,OAAQ,CAAA,KAAA,CAAM,6BAA+BA,CAAAA,CAAG,CAChDT,CAAAA,CAAAA,CAASS,CAAG,EACd,CACF,CACA,CAAA,CAACf,CAAG,CACN,CAEMgB,CAAAA,CAAAA,CAAe,SAAY,CAC/B,GAAI,CACEhB,CAAAA,EACF,MAAMA,CAAI,CAAA,YAAA,GAEd,CAAA,MAASe,EAAK,CACZ,OAAA,CAAQ,KAAM,CAAA,+BAAA,CAAiCA,CAAG,CAAA,CAClDT,CAASS,CAAAA,CAAG,EACd,CAAE,OAAA,CACAjB,CAAY,CAAA,KAAA,EACZM,CAAAA,CAAAA,CAAgB,CAAK,CAAA,EACvB,CACF,CAEA,CAAA,OACEa,GAAC1B,CAAAA,CAAAA,CAAgB,QAAhB,CAAA,CACC,KAAO,CAAA,CACL,IAAAS,CACA,CAAA,SAAA,CAAAY,CACA,CAAA,YAAA,CAAAT,EACA,SAAWI,CAAAA,CAAAA,CACX,KAAAF,CAAAA,CAAAA,CACA,WAAY,SAAYL,CAAAA,EAAK,UAAW,EAAA,CACxC,YAAc,CAAA,SAAYgB,CAAa,EACzC,EAEC,QAAAtB,CAAAA,CAAAA,CACH,CAEJ,ECnFO,IAAMwB,EAAO,CAClB,MAAA,CAAQ,CAAC,UAAU,EACnB,cAAgB,CAAA,CAAC,UAAY,CAAA,cAAc,EAC3C,UAAaC,CAAAA,CAAAA,EAAsB,CACjC,UAAA,CACA,SACA,CAAA,GAAIA,CAAY,CAAA,CAACA,CAAS,CAAI,CAAA,EAChC,CAAA,CACA,YAAa,CAAC,UAAA,CAAY,UAAU,CAAA,CACpC,YAAcA,CAAuB,EAAA,CACnC,UACA,CAAA,UAAA,CACA,GAAIA,CAAAA,CAAY,CAACA,CAAS,EAAI,EAChC,CACA,CAAA,SAAA,CAAW,CAAC,UAAY,CAAA,QAAQ,CAChC,CAAA,QAAA,CAAWC,GAAoB,CAAC,UAAA,CAAY,OAASA,CAAAA,CAAO,CAC5D,CAAA,SAAA,CAAYC,CAAqB,EAAA,CAC/B,WACA,QACA,CAAA,GAAIA,CAAS,CAAA,CAACA,CAAM,CAAA,CAAI,EAC1B,EACA,UAAY,CAAA,CAAC,UAAY,CAAA,aAAa,CACtC,CAAA,WAAA,CAAa,CAAC,UAAA,CAAY,cAAc,CAC1C,EAGA,SAASC,CAAAA,EAAqC,CAC5C,IAAMC,CAAAA,CAAUC,UAAWjC,CAAAA,CAAe,EAE1C,GAAIgC,CAAAA,GAAY,IACd,CAAA,MAAM,IAAI,KAAA,CAAM,+CAA+C,CAAA,CAEjE,OAAOA,CAAS,EAAA,GAClB,CAuBO,SAASE,CAAyB,EAAA,CACvC,IAAMF,CAAAA,CAAUC,WAAWjC,CAAe,CAAA,CAE1C,GAAIgC,CAAAA,GAAY,IACd,CAAA,MAAM,IAAI,KAAA,CAAM,gDAAgD,CAElE,CAAA,OAAO,CACL,YAAA,CAAcA,EAAQ,YACtB,CAAA,SAAA,CAAWA,CAAQ,CAAA,SAAA,CACnB,UAAWA,CAAQ,CAAA,SAAA,CACnB,KAAOA,CAAAA,CAAAA,CAAQ,KACf,CAAA,UAAA,CAAYA,CAAQ,CAAA,UAAA,CACpB,aAAcA,CAAQ,CAAA,YACxB,CACF,CA0BO,SAASG,CAAAA,CAAe,CAC7B,KAAA,CAAAC,CACF,CAEI,CAAA,EAA6C,CAAA,CAC/C,GAAM,CAAE,YAAAxB,CAAAA,CAAa,EAAIsB,CAAQ,EAAA,CAC3BzB,CAAMsB,CAAAA,CAAAA,GAEN,CAAE,IAAA,CAAAM,CAAM,CAAA,GAAGC,CAAK,CAAIC,CAAAA,QAAAA,CAAS,CACjC,GAAGH,CACH,CAAA,QAAA,CAAUT,CAAK,CAAA,cAAA,CACf,QAAS,SAAY,CACnB,GAAI,CAAClB,EACH,MAAM,IAAI,KAAM,CAAA,2BAA2B,EAE7C,GAAI,CAACG,CACH,CAAA,MAAM,IAAI,KAAA,CAAM,qBAAqB,CAAA,CAEvC,OAAOH,CAAI,CAAA,cAAA,EACb,CAAA,CACA,QAAS,CAAQA,EAAAA,CAAAA,EAAOG,CAAiBwB,GAAAA,CAAAA,EAAO,SAAW,CAC7D,CAAA,CAAA,CAAA,CAAC,CACD,CAAA,OAAO,CACL,WAAA,CAAaC,CACb,CAAA,GAAGC,CACL,CACF,CA2BO,SAASE,CAAAA,CAAW,CACzB,SAAA,CAAAZ,CACA,CAAA,KAAA,CAAAQ,CACF,CAGI,CAAA,EAAqC,CAAA,CACvC,GAAM,CAAE,YAAAxB,CAAAA,CAAa,EAAIsB,CAAQ,EAAA,CAC3BzB,CAAMsB,CAAAA,CAAAA,GACN,CAAE,WAAA,CAAAU,CAAY,CAAA,CAAIN,GAElBO,CAAAA,CAAAA,CAAiBd,CAAca,EAAAA,CAAAA,EAAa,cAE5C,CAAA,CAAE,IAAAJ,CAAAA,CAAAA,CAAM,GAAGC,CAAK,CAAA,CAAIC,QAAS,CAAA,CACjC,GAAGH,CAAAA,CACH,QAAUT,CAAAA,CAAAA,CAAK,WAAWe,CAAc,CAAA,CACxC,OAAS,CAAA,SAAY,CACnB,GAAI,CAACjC,CAAAA,CACH,MAAM,IAAI,KAAA,CAAM,2BAA2B,CAAA,CAE7C,GAAI,CAACG,CAAAA,CACH,MAAM,IAAI,MAAM,qBAAqB,CAAA,CAEvC,GAAI,CAAC8B,CACH,CAAA,MAAM,IAAI,KAAA,CAAM,wBAAwB,CAG1C,CAAA,OAAOjC,CAAI,CAAA,UAAA,CAAWiC,CAAc,CACtC,CACA,CAAA,OAAA,CAAS,GACPjC,CAAOG,EAAAA,CAAAA,EAAgB8B,CAAmBN,GAAAA,CAAAA,EAAO,OAAW,EAAA,CAAA,CAAA,CAAA,CAEhE,CAAC,CAAA,CACD,OAAO,CACL,OAAA,CAASC,CACT,CAAA,GAAGC,CACL,CACF,CAwBO,SAASK,CAAAA,CAAY,CAC1B,KAAAP,CAAAA,CACF,CAEI,CAAA,EAAwC,CAAA,CAC1C,GAAM,CAAE,aAAAxB,CAAa,CAAA,CAAIsB,CAAQ,EAAA,CAC3BzB,EAAMsB,CAAO,EAAA,CAEb,CAAE,IAAA,CAAAM,EAAM,GAAGC,CAAK,CAAIC,CAAAA,QAAAA,CAAS,CACjC,GAAGH,CACH,CAAA,QAAA,CAAUT,EAAK,WACf,CAAA,OAAA,CAAS,SAAY,CACnB,GAAI,CAAClB,CAAAA,CACH,MAAM,IAAI,MAAM,2BAA2B,CAAA,CAE7C,GAAI,CAACG,CACH,CAAA,MAAM,IAAI,KAAA,CAAM,qBAAqB,CAEvC,CAAA,OAAOH,CAAI,CAAA,WAAA,EACb,CAAA,CACA,OAAS,CAAA,CAAA,EAAQA,GAAOG,CAAiBwB,GAAAA,CAAAA,EAAO,OAAW,EAAA,CAAA,CAAA,CAAA,CAC7D,CAAC,CAAA,CACD,OAAO,CACL,SAAUC,CACV,CAAA,GAAGC,CACL,CACF,CAwBO,SAASM,CAAAA,CAAU,CACxB,KAAA,CAAAR,CACF,CAAuC,CAAA,EAAoC,CAAA,CACzE,IAAM3B,CAAAA,CAAMsB,CAAO,EAAA,CACb,CAAE,YAAAnB,CAAAA,CAAa,CAAIsB,CAAAA,CAAAA,EACnB,CAAA,CAAE,IAAAG,CAAAA,CAAAA,CAAM,GAAGC,CAAK,CAAA,CAAIC,QAAS,CAAA,CACjC,GAAGH,CAAAA,CACH,QAAUT,CAAAA,CAAAA,CAAK,UACf,OAAS,CAAA,SAAY,CACnB,GAAI,CAAClB,CACH,CAAA,MAAM,IAAI,KAAA,CAAM,2BAA2B,CAE7C,CAAA,GAAI,CAACG,CAAAA,CACH,MAAM,IAAI,KAAM,CAAA,qBAAqB,EAEvC,OAAOH,CAAAA,CAAI,SAAU,EACvB,CACA,CAAA,OAAA,CAAS,CAAQA,EAAAA,CAAAA,EAAOG,IAAiBwB,CAAO,EAAA,OAAA,EAAW,CAC7D,CAAA,CAAA,CAAA,CAAC,CACD,CAAA,OAAO,CACL,MAAA,CAAQC,EACR,GAAGC,CACL,CACF,CAyBO,SAASO,CAAY,CAAA,CAC1B,SAAAjB,CAAAA,CAAAA,CACA,MAAAQ,CACF,CAAA,CAGI,EAAC,CAAwC,CAC3C,IAAM3B,CAAMsB,CAAAA,CAAAA,GACN,CAAE,YAAA,CAAAnB,CAAa,CAAA,CAAIsB,GAEnB,CAAA,CAAE,IAAAG,CAAAA,CAAAA,CAAM,GAAGC,CAAK,CAAA,CAAIC,QAAS,CAAA,CACjC,GAAGH,CAAAA,CACH,QAAUT,CAAAA,CAAAA,CAAK,YAAYC,CAAS,CAAA,CACpC,OAAS,CAAA,SAAY,CACnB,GAAI,CAACnB,CACH,CAAA,MAAM,IAAI,KAAM,CAAA,2BAA2B,CAE7C,CAAA,GAAI,CAACG,CAAAA,CACH,MAAM,IAAI,MAAM,qBAAqB,CAAA,CAEvC,OAAOH,CAAAA,CAAI,WAAYmB,CAAAA,CAAS,CAClC,CAAA,CACA,QAAS,CAAQnB,EAAAA,CAAAA,EAAOG,CAAiBwB,GAAAA,CAAAA,EAAO,OAAW,EAAA,CAAA,CAAA,CAAA,CAC7D,CAAC,CAAA,CACD,OAAO,CACL,QAAA,CAAUC,CACV,CAAA,GAAGC,CACL,CACF,CAwBO,SAASQ,CAAAA,CAAS,CACvB,OAAAjB,CAAAA,CAAAA,CACA,KAAAO,CAAAA,CAAAA,CAAQ,EACV,CAGgC,CAAA,CAC9B,IAAM3B,CAAMsB,CAAAA,CAAAA,EACN,CAAA,CAAE,YAAAnB,CAAAA,CAAa,CAAIsB,CAAAA,CAAAA,GACnB,CAAE,IAAA,CAAAG,CAAM,CAAA,GAAGC,CAAK,CAAA,CAAIC,QAAS,CAAA,CACjC,GAAGH,CACH,CAAA,QAAA,CAAUT,CAAK,CAAA,QAAA,CAASE,CAAO,CAC/B,CAAA,OAAA,CAAS,SAAY,CACnB,GAAI,CAACpB,CAAAA,CACH,MAAM,IAAI,KAAM,CAAA,2BAA2B,CAE7C,CAAA,GAAI,CAACG,CACH,CAAA,MAAM,IAAI,KAAA,CAAM,qBAAqB,CAAA,CAEvC,GAAI,CAACiB,EACH,MAAM,IAAI,KAAM,CAAA,sBAAsB,CAGxC,CAAA,OAAOpB,CAAI,CAAA,QAAA,CAASoB,CAAO,CAC7B,CAAA,CACA,OAAS,CAAA,CAAA,EAAQpB,GAAOG,CAAgBiB,EAAAA,CAAAA,GAAYO,CAAM,CAAA,OAAA,EAAW,IACvE,CAAC,CAAA,CACD,OAAO,CACL,KAAOC,CAAAA,CAAAA,CACP,GAAGC,CACL,CACF,CA6BO,SAASS,CAAU,CAAA,CACxB,MAAAX,CAAQ,CAAA,EACR,CAAA,GAAGY,CACL,CAOI,CAAA,EAAoC,CAAA,CACtC,IAAMvC,CAAAA,CAAMsB,CAAO,EAAA,CACb,CAAE,YAAAnB,CAAAA,CAAa,CAAIsB,CAAAA,CAAAA,GACnB,CAAE,IAAA,CAAAG,CAAM,CAAA,GAAGC,CAAK,CAAIC,CAAAA,QAAAA,CAAS,CACjC,GAAGH,CACH,CAAA,QAAA,CAAUT,CAAK,CAAA,SAAA,CAAUqB,CAAO,CAChC,CAAA,OAAA,CAAS,SAAY,CACnB,GAAI,CAACvC,CACH,CAAA,MAAM,IAAI,KAAM,CAAA,2BAA2B,CAE7C,CAAA,GAAI,CAACG,CAAAA,CACH,MAAM,IAAI,MAAM,qBAAqB,CAAA,CAGvC,OAAOH,CAAAA,CAAI,UAAUuC,CAAO,CAC9B,CACA,CAAA,OAAA,CAAS,GAAQvC,CAAOG,EAAAA,CAAAA,GAAiBwB,CAAM,CAAA,OAAA,EAAW,CAC5D,CAAA,CAAA,CAAA,CAAC,CACD,CAAA,OAAO,CACL,MAAQC,CAAAA,CAAAA,CACR,GAAGC,CACL,CACF,CA6BO,SAASW,CAAAA,CAAc,CAC5B,kBAAAC,CAAAA,CAAAA,CACA,QAAAC,CAAAA,CACF,CAGI,CAAA,EAA0D,CAAA,CAC5D,IAAM1C,CAAMsB,CAAAA,CAAAA,EACN,CAAA,CAAE,aAAAnB,CAAa,CAAA,CAAIsB,CAAQ,EAAA,CAC3B3B,EAAcC,cAAe,EAAA,CAE7B,CAAE,WAAA,CAAA4C,CAAa,CAAA,GAAGd,CAAK,CAAA,CAAIe,YAAY,CAC3C,GAAGF,CACH,CAAA,WAAA,CAAaxB,CAAK,CAAA,UAAA,CAClB,UAAY,CAAA,MAAO2B,GAAmB,CACpC,GAAI,CAAC7C,CAAAA,CACH,MAAM,IAAI,KAAM,CAAA,2BAA2B,EAE7C,GAAI,CAACG,CACH,CAAA,MAAM,IAAI,KAAM,CAAA,qBAAqB,CAEvC,CAAA,IAAI2C,EACJ,GAAI,QAAA,CAASD,CAAK,CAAA,MAAM,CAAI,CAAA,IAAA,CAAO,CACjC,GAAI,CAACJ,CACH,CAAA,MAAM,IAAI,KAAA,CACR,wDACF,CAIFK,CAAAA,CAAAA,CAAAA,CADE,MAAM9C,CAAAA,CAAI,yBAAyByC,CAAkB,CAAA,EACzB,GAChC,CAEA,IAAMM,CAAAA,CAAU,CACd,GAAGF,EACH,UAAYC,CAAAA,CACd,CAEA,CAAA,OAAO9C,EAAI,UAAW+C,CAAAA,CAAO,CAC/B,CAAA,CACA,UAAUnB,CAAMoB,CAAAA,CAAAA,CAAWzB,CAAS,CAAA,CAElCzB,CAAY,CAAA,iBAAA,CAAkB,CAC5B,QAAA,CAAUoB,EAAK,SAAU,EAC3B,CAAC,CAAA,CAEDwB,CAAU,EAAA,SAAA,GAAYd,CAAMoB,CAAAA,CAAAA,CAAWzB,CAAO,EAChD,CAAA,CACA,OAAQlB,CAAAA,CAAAA,CAAO4C,CAAM1B,CAAAA,CAAAA,CAAS,CAE5B,MAAAmB,GAAU,OAAUrC,GAAAA,CAAAA,CAAO4C,CAAM1B,CAAAA,CAAO,EAClClB,CACR,CACF,CAAC,CAAA,CACD,OAAO,CACL,UAAA,CAAYsC,CACZ,CAAA,GAAGd,CACL,CACF,CA0BO,SAASqB,EAAe,CAC7B,SAAA,CAAA/B,CACA,CAAA,QAAA,CAAAuB,CACF,CAGqE,CAAA,CACnE,IAAM1C,CAAAA,CAAMsB,GACN,CAAA,CAAE,YAAAnB,CAAAA,CAAa,CAAIsB,CAAAA,CAAAA,EACnB3B,CAAAA,CAAAA,CAAcC,gBAEd,CAAA,CAAE,WAAA4C,CAAAA,CAAAA,CAAa,GAAGd,CAAK,CAAA,CAAIe,WAAY,CAAA,CAC3C,GAAGF,CACH,CAAA,WAAA,CAAaxB,CAAK,CAAA,WAAA,CAClB,UAAY,CAAA,MAAO2B,CAAsB,EAAA,CACvC,GAAI,CAAC7C,CAAAA,CACH,MAAM,IAAI,KAAM,CAAA,2BAA2B,CAE7C,CAAA,GAAI,CAACG,CACH,CAAA,MAAM,IAAI,KAAA,CAAM,qBAAqB,CAAA,CAEvC,OAAOH,CAAAA,CAAI,YAAYmB,CAAW0B,CAAAA,CAAI,CACxC,CAAA,CACA,UAAUjB,CAAMoB,CAAAA,CAAAA,CAAWzB,CAAS,CAAA,CAElCzB,EAAY,iBAAkB,CAAA,CAC5B,QAAUoB,CAAAA,CAAAA,CAAK,UAAWC,CAAAA,CAAS,CACrC,CAAC,EAEDuB,CAAU,EAAA,SAAA,GAAYd,CAAMoB,CAAAA,CAAAA,CAAWzB,CAAO,EAChD,CAAA,CACA,OAAQlB,CAAAA,CAAAA,CAAO4C,EAAM1B,CAAS,CAAA,CAE5B,MAAAmB,CAAAA,EAAU,OAAUrC,GAAAA,CAAAA,CAAO4C,CAAM1B,CAAAA,CAAO,EAClClB,CACR,CACF,CAAC,CAAA,CACD,OAAO,CACL,WAAA,CAAasC,CACb,CAAA,GAAGd,CACL,CACF","file":"index.mjs","sourcesContent":["import { createContext } from 'react';\n\nimport { SdkInstance, UseAuthReturn } from './types';\n\nexport const MoneriumContext = createContext<\n  (UseAuthReturn & SdkInstance) | null\n>(null);\n","import { ReactNode, useCallback, useEffect, useState } from 'react';\nimport { useQueryClient } from '@tanstack/react-query';\n\nimport { MoneriumClient } from '@monerium/sdk';\n\nimport { MoneriumContext } from './context';\nimport { AuthorizeParams } from './types';\n\n/**\n * Place this provider at the root of your application.\n * @group Provider\n * @param params\n * @param params.children - Rest of the application.\n * @param params.clientId - Monerium auth flow client id.\n * @param params.redirectUrl - Monerium auth flow redirect url.\n * @param params.environment - Monerium environment.\n * @returns\n */\nexport const MoneriumProvider = ({\n  children,\n  clientId = 'f99e629b-6dca-11ee-8aa6-5273f65ed05b',\n  redirectUrl = 'http://localhost:5173',\n  environment = 'sandbox',\n}: {\n  children: ReactNode;\n  clientId?: string;\n  redirectUrl?: string;\n  environment?: 'sandbox' | 'production';\n}) => {\n  const queryClient = useQueryClient();\n\n  const [sdk, setSdk] = useState<MoneriumClient>();\n  const [isAuthorized, setIsAuthorized] = useState<boolean>(false);\n  const [error, setError] = useState<Error | unknown | null>(null);\n  const [loadingAuth, setLoadingAuth] = useState(true);\n\n  // Initialize the SDK\n  useEffect(() => {\n    const sdkInstance = new MoneriumClient({\n      environment: environment,\n      clientId,\n      redirectUrl,\n    });\n    setSdk(sdkInstance);\n  }, []);\n\n  useEffect(() => {\n    const connect = async () => {\n      if (sdk) {\n        try {\n          setIsAuthorized(await sdk.getAccess());\n        } catch (error) {\n          console.error('Failed to get access:', error);\n        } finally {\n          setLoadingAuth(false);\n        }\n      }\n    };\n\n    connect();\n\n    return () => {\n      if (sdk) {\n        sdk.disconnect();\n      }\n    };\n  }, [sdk]);\n\n  const authorize = useCallback(\n    async (params?: AuthorizeParams) => {\n      try {\n        if (sdk) {\n          await sdk.authorize(params);\n        }\n      } catch (err) {\n        console.error('Error during authorization:', err);\n        setError(err);\n      }\n    },\n    [sdk]\n  );\n\n  const revokeAccess = async () => {\n    try {\n      if (sdk) {\n        await sdk.revokeAccess();\n      }\n    } catch (err) {\n      console.error('Error during revoking access:', err);\n      setError(err);\n    } finally {\n      queryClient.clear();\n      setIsAuthorized(false);\n    }\n  };\n\n  return (\n    <MoneriumContext.Provider\n      value={{\n        sdk,\n        authorize,\n        isAuthorized,\n        isLoading: loadingAuth,\n        error,\n        disconnect: async () => sdk?.disconnect(),\n        revokeAccess: async () => revokeAccess(),\n      }}\n    >\n      {children}\n    </MoneriumContext.Provider>\n  );\n};\n","import { useContext } from 'react';\nimport { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';\n\nimport MoneriumClient, {\n  AuthContext,\n  Balances,\n  LinkAddress,\n  LinkedAddress,\n  NewOrder,\n  Order,\n  OrderState,\n  Profile,\n  Token,\n} from '@monerium/sdk';\n\nimport { MoneriumContext } from './context';\nimport {\n  MutationOptions,\n  MutationResult,\n  QueryOptions,\n  QueryResult,\n  UseAuthReturn,\n} from './types';\n\n/**\n * @internal\n * Query keys\n * */\nexport const keys = {\n  getAll: ['monerium'],\n  getAuthContext: ['monerium', 'auth-context'],\n  getProfile: (profileId: string) => [\n    'monerium',\n    'profile',\n    ...(profileId ? [profileId] : []),\n  ],\n  getProfiles: ['monerium', 'profiles'],\n  getBalances: (profileId?: string) => [\n    'monerium',\n    'balances',\n    ...(profileId ? [profileId] : []),\n  ],\n  getTokens: ['monerium', 'tokens'],\n  getOrder: (orderId: string) => ['monerium', 'order', orderId],\n  getOrders: (filter?: unknown) => [\n    'monerium',\n    'orders',\n    ...(filter ? [filter] : []),\n  ],\n  placeOrder: ['monerium', 'place-order'],\n  linkAddress: ['monerium', 'link-address'],\n};\n\n/** Internal hook to use SDK */\nfunction useSdk(): MoneriumClient | undefined {\n  const context = useContext(MoneriumContext);\n\n  if (context === null) {\n    throw new Error('useSdk must be used within a MoneriumProvider');\n  }\n  return context?.sdk;\n}\n\n/**\n * # Redirect to the Monerium auth flow.\n * @group Hooks\n * @example\n * ```ts\n * const { authorize, isAuthorized, isLoading, error } = useAuth();\n *\n * authorize(); // Redirects to the Monerium auth flow.\n *\n * // To opt-in to automated wallet linking, pass the address, signature and chainId.\n * authorize({ address, signature, chainId }).\n * ```\n *\n * @returns {UseAuthReturn}\n * - `authorize`  - Redirects to the Monerium auth flow.\n * - `isAuthorized` - Whether the user is authorized.\n * - `isLoading` - Whether the auth flow is loading.\n * - `error` - Error message if the auth flow fails.\n * - `disconnect` - Disconnect the user.\n * - `revokeAccess` - Revoke the user's access.\n */\nexport function useAuth(): UseAuthReturn {\n  const context = useContext(MoneriumContext);\n\n  if (context === null) {\n    throw new Error('useAuth must be used within a MoneriumProvider');\n  }\n  return {\n    isAuthorized: context.isAuthorized,\n    authorize: context.authorize,\n    isLoading: context.isLoading,\n    error: context.error,\n    disconnect: context.disconnect,\n    revokeAccess: context.revokeAccess,\n  };\n}\n\n/**\n * # Get the authentication context.\n * @group Hooks\n *\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<AuthContext>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    authContext, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useAuthContext();\n * ```\n *\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/auth-context)\n *\n * [AuthContext interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/AuthContext.md)\n */\nexport function useAuthContext({\n  query,\n}: {\n  query?: QueryOptions<AuthContext>;\n} = {}): QueryResult<'authContext', AuthContext> {\n  const { isAuthorized } = useAuth();\n  const sdk = useSdk();\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getAuthContext,\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getAuthContext();\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    authContext: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get single profile\n * If no `profileId` is provided, the default profile is used.\n * @group Hooks\n * @param {Object} params\n * @param {string} [params.profileId] The id of the profile.\n * @param {QueryOptions<Profile>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    profile, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useProfile();\n * ```\n\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profile)\n *\n * [Profile interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Profile.md)\n */\nexport function useProfile({\n  profileId,\n  query,\n}: {\n  profileId?: string;\n  query?: QueryOptions<Profile>;\n} = {}): QueryResult<'profile', Profile> {\n  const { isAuthorized } = useAuth();\n  const sdk = useSdk();\n  const { authContext } = useAuthContext();\n\n  const profileIdToUse = profileId || (authContext?.defaultProfile as string);\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getProfile(profileIdToUse),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      if (!profileIdToUse) {\n        throw new Error('Profile Id is required');\n      }\n\n      return sdk.getProfile(profileIdToUse);\n    },\n    enabled: Boolean(\n      sdk && isAuthorized && profileIdToUse && (query?.enabled ?? true)\n    ),\n  });\n  return {\n    profile: data,\n    ...rest,\n  };\n}\n/**\n * # Get profiles\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<Profile[]>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    profiles, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useProfiles();\n * ```\n\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profiles)\n *\n * [Profile interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Profile.md)\n */\nexport function useProfiles({\n  query,\n}: {\n  query?: QueryOptions<Profile[]>;\n} = {}): QueryResult<'profiles', Profile[]> {\n  const { isAuthorized } = useAuth();\n  const sdk = useSdk();\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getProfiles,\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getProfiles();\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    profiles: data,\n    ...rest,\n  };\n}\n/**\n * # Get tokens\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<Token[]>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    tokens, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useTokens();\n * ```\n\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/tokens)\n *\n * [Token interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Token.md)\n */\nexport function useTokens({\n  query,\n}: { query?: QueryOptions<Token[]> } = {}): QueryResult<'tokens', Token[]> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getTokens,\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getTokens();\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    tokens: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get balances\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {QueryOptions<Balances[]>} [params.profileId] Fetch balances for a specific profile.\n * @param {QueryOptions<Balances[]>} [params.query] {@inheritDoc QueryOptions}\n\n * @example\n * ```ts\n * const {\n *    balances, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useBalances();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profile-balances)\n *\n * [Balances interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Balances.md)\n */\nexport function useBalances({\n  profileId,\n  query,\n}: {\n  profileId?: string;\n  query?: QueryOptions<Balances[]>;\n} = {}): QueryResult<'balances', Balances[]> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getBalances(profileId),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.getBalances(profileId);\n    },\n    enabled: Boolean(sdk && isAuthorized && (query?.enabled ?? true)),\n  });\n  return {\n    balances: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get single order\n * @group Hooks\n * @param {Object} params\n * @param {Object} params.orderId The id of the order.\n * @param {QueryOptions<Order>} [params.query] {@inheritDoc QueryOptions}\n * @example\n * ```ts\n * const {\n *    order, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useOrder();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/order)\n *\n * [Order interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Order.md)\n */\nexport function useOrder({\n  orderId,\n  query = {},\n}: {\n  orderId: string;\n  query?: QueryOptions<Order>;\n}): QueryResult<'order', Order> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getOrder(orderId),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      if (!orderId) {\n        throw new Error('Order id is required');\n      }\n\n      return sdk.getOrder(orderId);\n    },\n    enabled: Boolean(sdk && isAuthorized && orderId && (query.enabled ?? true)),\n  });\n  return {\n    order: data,\n    ...rest,\n  };\n}\n\n/**\n * # Get orders\n * @group Hooks\n * @param {Object} [params] No required parameters.\n * @param {Object} [params.address] Filter based on the blockchain address associated with the order.\n * @param {Object} [params.memo] Filter by the payment memo/reference..\n * @param {Object} [params.profile] Filter based on the profile ID associated with the order.\n * @param {Object} [params.state] Filter based on the state of the order.\n * @param {Object} [params.txHash] Filter based on the blockchain transaction hash.\n * @param {QueryOptions<Order[]>} [params.query] {@inheritDoc QueryOptions}\n *\n * @example\n * ```ts\n * const {\n *    orders, // useQuery's `data` property\n *    isLoading,\n *    isError,\n *    error,\n *    refetch,\n *    ...moreUseQueryResults\n * } = useOrders();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/orders)\n *\n * [Order interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/Order.md)\n */\nexport function useOrders({\n  query = {},\n  ...filters\n}: {\n  query?: QueryOptions<Order[]>;\n  address?: string;\n  txHash?: string;\n  profile?: string;\n  memo?: string;\n  state?: OrderState;\n} = {}): QueryResult<'orders', Order[]> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const { data, ...rest } = useQuery({\n    ...query,\n    queryKey: keys.getOrders(filters),\n    queryFn: async () => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n\n      return sdk.getOrders(filters);\n    },\n    enabled: Boolean(sdk && isAuthorized && (query.enabled ?? true)),\n  });\n  return {\n    orders: data,\n    ...rest,\n  };\n}\n\n/**\n * # Place an order.\n * When the order has been placed, the orders query will be invalidated and re-fetched.\n *\n * If the order amount is above 15000, a supporting document is required.\n * @group Hooks\n * @param param\n * @param {File} param.supportingDocument Supporting document file.\n * @param {Object} param.mutation {@inheritDoc MutationOptions}\n *\n * @example\n * ```ts\n * const {\n *    placeOrder, // useMutation's `mutateAsync` property\n *    isPending,\n *    isError,\n *    error,\n *    status,\n *    ...moreUseMutationResults\n * } = usePlaceOrder();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/post-orders)\n *\n * [NewOrder type](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/type-aliases/NewOrder.md)\n */\n\nexport function usePlaceOrder({\n  supportingDocument,\n  mutation,\n}: {\n  supportingDocument?: File;\n  mutation?: MutationOptions<Order, Error, NewOrder>;\n} = {}): MutationResult<'placeOrder', Order, Error, NewOrder> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const queryClient = useQueryClient();\n\n  const { mutateAsync, ...rest } = useMutation({\n    ...mutation,\n    mutationKey: keys.placeOrder,\n    mutationFn: async (body: NewOrder) => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      let documentId;\n      if (parseInt(body.amount) > 15000) {\n        if (!supportingDocument) {\n          throw new Error(\n            'Supporting document is required for orders above 15000'\n          );\n        }\n        const uploadedDocument =\n          await sdk.uploadSupportingDocument(supportingDocument);\n        documentId = uploadedDocument.id;\n      }\n\n      const newBody = {\n        ...body,\n        documentId: documentId,\n      };\n\n      return sdk.placeOrder(newBody);\n    },\n    onSuccess(data, variables, context) {\n      // Refetch all orders on success.\n      queryClient.invalidateQueries({\n        queryKey: keys.getOrders(),\n      });\n      // Allow the caller to add custom logic on success.\n      mutation?.onSuccess?.(data, variables, context);\n    },\n    onError(error, vars, context) {\n      // Allow the caller to add custom logic on error.\n      mutation?.onError?.(error, vars, context);\n      throw error;\n    },\n  });\n  return {\n    placeOrder: mutateAsync,\n    ...rest,\n  };\n}\n/**\n * # Add address to profile.\n * When the address has been linked, the relevant profile query will be invalidated and re-fetched.\n *\n * @group Hooks\n * @param param\n * @param {File} param.profileId Which profile to link the address.\n * @param {Object} param.mutation {@inheritDoc MutationOptions}\n *\n * @example\n * ```ts\n * const {\n *    linkAddress, // useMutation's `mutateAsync` property\n *    isPending,\n *    isError,\n *    error,\n *    status,\n *    ...moreUseMutationResults\n * } = useLinkAddress();\n * ```\n * @see\n * [API Documentation](https://monerium.dev/api-docs#operation/profile-addresses)\n *\n * [LinkAddress interface](https://github.com/monerium/js-monorepo/blob/main/packages/sdk/docs/generated/interfaces/LinkAddress.md)\n */\nexport function useLinkAddress({\n  profileId,\n  mutation,\n}: {\n  profileId: string;\n  mutation?: MutationOptions<LinkedAddress, Error, LinkAddress>;\n}): MutationResult<'linkAddress', LinkedAddress, Error, LinkAddress> {\n  const sdk = useSdk();\n  const { isAuthorized } = useAuth();\n  const queryClient = useQueryClient();\n\n  const { mutateAsync, ...rest } = useMutation({\n    ...mutation,\n    mutationKey: keys.linkAddress,\n    mutationFn: async (body: LinkAddress) => {\n      if (!sdk) {\n        throw new Error('No SDK instance available');\n      }\n      if (!isAuthorized) {\n        throw new Error('User not authorized');\n      }\n      return sdk.linkAddress(profileId, body);\n    },\n    onSuccess(data, variables, context) {\n      // Refetch all orders on success.\n      queryClient.invalidateQueries({\n        queryKey: keys.getProfile(profileId),\n      });\n      // Allow the caller to add custom logic on success.\n      mutation?.onSuccess?.(data, variables, context);\n    },\n    onError(error, vars, context) {\n      // Allow the caller to add custom logic on error.\n      mutation?.onError?.(error, vars, context);\n      throw error;\n    },\n  });\n  return {\n    linkAddress: mutateAsync,\n    ...rest,\n  };\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monerium/sdk-react-provider",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "description": "React provider for the Monerium SDK.",
   "repository": {
@@ -27,24 +27,29 @@
     "dist/index.d.ts"
   ],
   "dependencies": {
-    "@monerium/sdk": "2.13.0"
+    "@monerium/sdk": "latest"
   },
   "peerDependencies": {
+    "@tanstack/react-query": ">=5.0.0",
     "@types/react": "^18.2.61",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "react": ">=18.2.0",
+    "react-dom": ">=18.2.0"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.1.0",
     "@testing-library/jest-dom": "^6.4.6",
-    "@testing-library/react": "^16.0.0"
+    "@testing-library/react": "^16.0.0",
+    "undici": "^6.19.4"
   },
   "scripts": {
-    "dev": "tsup --watch",
     "build": "tsup",
+    "dev": "tsup --watch --onSuccess 'pnpm type-map'",
+    "docs": "typedoc",
+    "docs:watch": "typedoc  --watch",
     "lint": "eslint . --fix",
     "pub:pre": "pnpm publish --no-git-checks --dry-run",
     "test": "jest",
-    "test:watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "type-map": "tsc --emitDeclarationOnly --declaration"
   }
 }