@mezo-org/passport 0.4.0-dev.4 → 0.4.0-dev.42

package/dist/src/hooks/useAssetsConversionRates.js

@@ -0,0 +1,24 @@
+import { useQuery } from "@tanstack/react-query";
+import { ONE_MINUTE_MS } from "../utils/time";
+import { QUERY_KEYS } from "./constants";
+import { usePortalApiClient } from "./usePortalApiClient";
+export default function useAssetsConversionRates(useQueryOptions = {}) {
+    const portalApiClient = usePortalApiClient();
+    return useQuery({
+        queryKey: [QUERY_KEYS.ASSETS_USD_CONVERSION],
+        queryFn: async () => {
+            const { currentUsdPerBtc, currentUsdPerEth, currentUsdPerTToken } = await portalApiClient.getPortalStatistics();
+            return {
+                usd: {
+                    btc: Number(currentUsdPerBtc),
+                    eth: Number(currentUsdPerEth),
+                    t: Number(currentUsdPerTToken),
+                },
+            };
+        },
+        staleTime: 30 * ONE_MINUTE_MS,
+        retry: 1,
+        ...useQueryOptions,
+    });
+}
+//# sourceMappingURL=useAssetsConversionRates.js.map

package/dist/src/hooks/useAssetsConversionRates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetsConversionRates.js","sourceRoot":"","sources":["../../../src/hooks/useAssetsConversionRates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAMzD,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAC9C,kBAAqE,EAAE;IAEvE,MAAM,eAAe,GAAG,kBAAkB,EAAE,CAAA;IAE5C,OAAO,QAAQ,CAAC;QACd,QAAQ,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;QAC5C,OAAO,EAAE,KAAK,IAAI,EAAE;YAClB,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,GAC/D,MAAM,eAAe,CAAC,mBAAmB,EAAE,CAAA;YAC7C,OAAO;gBACL,GAAG,EAAE;oBACH,GAAG,EAAE,MAAM,CAAC,gBAAgB,CAAC;oBAC7B,GAAG,EAAE,MAAM,CAAC,gBAAgB,CAAC;oBAC7B,CAAC,EAAE,MAAM,CAAC,mBAAmB,CAAC;iBAC/B;aACF,CAAA;QACH,CAAC;QACD,SAAS,EAAE,EAAE,GAAG,aAAa;QAC7B,KAAK,EAAE,CAAC;QACR,GAAG,eAAe;KACnB,CAAC,CAAA;AACJ,CAAC"}

package/dist/src/hooks/useAuthApiClient.d.ts

@@ -1,2 +1,2 @@
-export declare function useAuthApiClient(): import("../api/auth").AuthApiClient;
+export declare function useAuthApiClient(): import("../api").AuthApiClient;
 //# sourceMappingURL=useAuthApiClient.d.ts.map

package/dist/src/hooks/useAuthApiClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAuthApiClient.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAuthApiClient.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,wCAG/B"}
+{"version":3,"file":"useAuthApiClient.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAuthApiClient.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,mCAG/B"}

package/dist/src/hooks/useAuthenticateWithWallet.d.ts

@@ -0,0 +1,73 @@
+import { MutationOptions } from "@tanstack/react-query";
+import type { Session } from "../api";
+declare function useAuthenticateWithWallet(shouldCreateAccount?: boolean, mutationOptions?: Omit<MutationOptions<Session>, "mutationFn" | "mutationKey">): {
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    authenticateWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    authenticateWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
+} | {
+    data: undefined;
+    variables: void;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    authenticateWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    authenticateWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
+} | {
+    data: undefined;
+    error: Error;
+    variables: void;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    authenticateWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    authenticateWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
+} | {
+    data: Session;
+    error: null;
+    variables: void;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    authenticateWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    authenticateWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
+};
+export { useAuthenticateWithWallet };
+//# sourceMappingURL=useAuthenticateWithWallet.d.ts.map

package/dist/src/hooks/useAuthenticateWithWallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthenticateWithWallet.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAuthenticateWithWallet.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAe,MAAM,uBAAuB,CAAA;AAMpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAGrC,iBAAS,yBAAyB,CAChC,mBAAmB,UAAQ,EAC3B,eAAe,GAAE,IAAI,CACnB,eAAe,CAAC,OAAO,CAAC,EACxB,YAAY,GAAG,aAAa,CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFP;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAA"}

package/dist/src/hooks/useAuthenticateWithWallet.js

@@ -0,0 +1,69 @@
+import { useSignMessage } from "wagmi";
+import { useMutation } from "@tanstack/react-query";
+import { useCreateAccount } from "./useCreateAccount";
+import { useCreateSession } from "./useCreateSession";
+import { useEnsureNoSessionAndFetchNonce } from "./useEnsureNoSessionAndFetchNonce";
+import { createSignInWithWalletMessage } from "../utils/siww";
+import { useGetAccountByAddress } from "./useGetAccountByAddress";
+import useWalletAccount from "./useWalletAccount";
+function useAuthenticateWithWallet(shouldCreateAccount = false, mutationOptions = {}) {
+    const { walletAddress, chainId, connector, networkFamily } = useWalletAccount();
+    const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce();
+    const { createSessionAsync } = useCreateSession();
+    const { createAccountAsync } = useCreateAccount();
+    const { signMessageAsync } = useSignMessage();
+    const { refetch: getAccountByAddress } = useGetAccountByAddress(walletAddress, {
+        enabled: false,
+        retry: false,
+    });
+    const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
+        mutationFn: async () => {
+            if (!walletAddress) {
+                throw new Error("Sign in error: Wallet not connected!");
+            }
+            const nonce = await ensureNoSessionAndFetchNonce();
+            const messageResult = createSignInWithWalletMessage(walletAddress, nonce, networkFamily, chainId);
+            const signatureResult = await signMessageAsync({
+                message: messageResult,
+                connector,
+            });
+            if (shouldCreateAccount) {
+                const getAccountByAddressResult = await getAccountByAddress();
+                if (getAccountByAddressResult.data) {
+                    throw new Error("Wallet authentication failed: Account creation failed. Account already exists.");
+                }
+                if (getAccountByAddressResult.error) {
+                    throw new Error(`Wallet authentication failed: Account creation failed. Could not verify if account already exists: ${getAccountByAddressResult.error}`);
+                }
+                // Fetch was successful, but no account was found
+                try {
+                    const createAccountResult = await createAccountAsync({
+                        type: "wallet",
+                        message: messageResult,
+                        signature: signatureResult,
+                    });
+                    if (!createAccountResult) {
+                        throw new Error("Failed to create new account");
+                    }
+                }
+                catch (error) {
+                    throw new Error(`Wallet authentication failed: Account creation failed: ${error}`);
+                }
+            }
+            return (await createSessionAsync({
+                type: "wallet",
+                message: messageResult,
+                signature: signatureResult,
+            }));
+            // ^ By passing type: "wallet" we know for sure the return type is Session
+        },
+        ...mutationOptions,
+    });
+    return {
+        authenticateWithWallet: mutate,
+        authenticateWithWalletAsync: mutateAsync,
+        ...signInMutationRestParameters,
+    };
+}
+export { useAuthenticateWithWallet };
+//# sourceMappingURL=useAuthenticateWithWallet.js.map

package/dist/src/hooks/useAuthenticateWithWallet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthenticateWithWallet.js","sourceRoot":"","sources":["../../../src/hooks/useAuthenticateWithWallet.ts"],"names":[],"mappings":"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"}

package/dist/src/hooks/useBorrowData.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Query hook for getting borrow data. Returns collateral and trove debt for the
+ * connected account, based on it's evm address.
+ * @param queryOptions Query options passed to the underlying `useQuery` hook.
+ */
+export declare function useBorrowData(queryOptions?: {}): import("wagmi").UseReadContractReturnType<readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_borrower";
+        readonly type: "address";
+    }];
+    readonly name: "getEntireDebtAndColl";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "coll";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "principal";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "interest";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "pendingCollateral";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "pendingPrincipal";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "pendingInterest";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}], "getEntireDebtAndColl", [`0x${string}`], {
+    collateral: bigint;
+    troveDebt: bigint;
+} | undefined>;
+/**
+ * Hook for for invalidating current user's borrow data. Can be used to
+ * invalidate borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `invalidateBorrowData` for invalidating the borrow data
+ */
+export declare function useInvalidateBorrowData(): {
+    invalidateBorrowData: () => Promise<void>;
+};
+/**
+ * Hook for for resetting current user's borrow data. Can be used to reset
+ * borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `resetBorrowData` for resetting the borrow data
+ */
+export declare function useResetBorrowData(): {
+    resetBorrowData: () => Promise<void>;
+};
+//# sourceMappingURL=useBorrowData.d.ts.map

package/dist/src/hooks/useBorrowData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBorrowData.d.ts","sourceRoot":"","sources":["../../../src/hooks/useBorrowData.ts"],"names":[],"mappings":"AAgEA;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,YAAY,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAiC9C;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB;;EAatC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB;;EAajC"}

package/dist/src/hooks/useBorrowData.js

@@ -0,0 +1,122 @@
+import { useAccount, useReadContract } from "wagmi";
+import { useCallback, useMemo } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { ONE_MINUTE_MS } from "../utils/time";
+import { mainnetBorrowContracts, testnetBorrowContracts, } from "../lib/contracts";
+import { usePassportContext } from "./usePassportContext";
+import { CHAIN_ID } from "../constants";
+// Wagmi handles typesafety with ABI const assertions. TypeScript doesn't
+// support importing JSON as const yet so types cannot be inferred from the
+// imported contract. As a workaround there is minimal ABI definition that can
+// be asserted types from.
+// Ref: https://wagmi.sh/core/typescript#const-assert-abis-typed-data
+const TROVE_MANAGER_ABI = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "_borrower",
+                type: "address",
+            },
+        ],
+        name: "getEntireDebtAndColl",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "coll",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "principal",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "interest",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "pendingCollateral",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "pendingPrincipal",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "pendingInterest",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+/**
+ * Query hook for getting borrow data. Returns collateral and trove debt for the
+ * connected account, based on it's evm address.
+ * @param queryOptions Query options passed to the underlying `useQuery` hook.
+ */
+export function useBorrowData(queryOptions = {}) {
+    const { environment = "mainnet" } = usePassportContext();
+    const { address } = useAccount();
+    const contractAddress = useMemo(() => {
+        if (environment === "mainnet") {
+            return mainnetBorrowContracts.TroveManager.address;
+        }
+        return testnetBorrowContracts.TroveManager.address;
+    }, [environment]);
+    return useReadContract({
+        abi: TROVE_MANAGER_ABI,
+        address: contractAddress,
+        functionName: "getEntireDebtAndColl",
+        args: [address || "0x"],
+        query: {
+            enabled: !!address,
+            staleTime: 5 * ONE_MINUTE_MS,
+            retry: 1,
+            select: (data) => {
+                if (!data)
+                    return undefined;
+                const [collateral, principal, interest] = data;
+                return {
+                    collateral,
+                    troveDebt: principal + interest,
+                };
+            },
+            ...queryOptions,
+        },
+        chainId: CHAIN_ID[environment],
+    });
+}
+/**
+ * Hook for for invalidating current user's borrow data. Can be used to
+ * invalidate borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `invalidateBorrowData` for invalidating the borrow data
+ */
+export function useInvalidateBorrowData() {
+    const queryClient = useQueryClient();
+    const { queryKey } = useBorrowData();
+    const invalidateBorrowDataHandler = useCallback(() => queryClient.invalidateQueries({ queryKey }), [queryClient, queryKey]);
+    return {
+        invalidateBorrowData: invalidateBorrowDataHandler,
+    };
+}
+/**
+ * Hook for for resetting current user's borrow data. Can be used to reset
+ * borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `resetBorrowData` for resetting the borrow data
+ */
+export function useResetBorrowData() {
+    const queryClient = useQueryClient();
+    const { queryKey } = useBorrowData();
+    const resetBorrowDataHandler = useCallback(() => queryClient.resetQueries({ queryKey }), [queryClient, queryKey]);
+    return {
+        resetBorrowData: resetBorrowDataHandler,
+    };
+}
+//# sourceMappingURL=useBorrowData.js.map

package/dist/src/hooks/useBorrowData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBorrowData.js","sourceRoot":"","sources":["../../../src/hooks/useBorrowData.ts"],"names":[],"mappings":"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"}

package/dist/src/hooks/useCreateAccount.d.ts

@@ -1,4 +1,6 @@
-export declare function useCreateAccount(useMutationOptions?: {}): {
+import { MutationOptions, DefaultError } from "@tanstack/react-query";
+import type { CreateAccountRequest, CreateAccountResponse } from "../api";
+export declare function useCreateAccount(mutationOptions?: Omit<MutationOptions<CreateAccountResponse, DefaultError, CreateAccountRequest>, "mutationFn" | "mutationKey">): {
     data: undefined;
     variables: undefined;
     error: null;
@@ -16,52 +18,16 @@ export declare function useCreateAccount(useMutationOptions?: {}): {
     createAccount: import("@tanstack/react-query").UseMutateFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
     createAccountAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
 } | {
     data: undefined;
-    variables: {
-        type: "wallet";
-        message: string;
-        signature: string;
-    };
+    variables: CreateAccountRequest;
     error: null;
     isError: false;
     isIdle: false;
@@ -77,53 +43,17 @@ export declare function useCreateAccount(useMutationOptions?: {}): {
     createAccount: import("@tanstack/react-query").UseMutateFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
     createAccountAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
 } | {
     data: undefined;
     error: Error;
-    variables: {
-        type: "wallet";
-        message: string;
-        signature: string;
-    };
+    variables: CreateAccountRequest;
     isError: true;
     isIdle: false;
     isPending: false;
@@ -138,69 +68,21 @@ export declare function useCreateAccount(useMutationOptions?: {}): {
     createAccount: import("@tanstack/react-query").UseMutateFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
     createAccountAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
 } | {
     data: {
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
+        linkedAccounts: import("../api").LinkedAccount[];
     };
     error: null;
-    variables: {
-        type: "wallet";
-        message: string;
-        signature: string;
-    };
+    variables: CreateAccountRequest;
     isError: false;
     isIdle: false;
     isPending: false;
@@ -215,44 +97,12 @@ export declare function useCreateAccount(useMutationOptions?: {}): {
     createAccount: import("@tanstack/react-query").UseMutateFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
     createAccountAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
         mezoId: string;
         hasModifiedMezoId: boolean;
-        linkedAccounts: import("../api/auth").LinkedAccount[];
-        authUser: {
-            id: string;
-            app_metadata: {
-                provider: "wallet" | "discord" | "email";
-                providers: ("wallet" | "discord" | "email")[];
-            };
-            user_metadata: {
-                mezoId?: string | undefined;
-                btcAddress: string;
-                evmAddress: string;
-            };
-        };
-    }, Error, {
-        type: "wallet";
-        message: string;
-        signature: string;
-    }, unknown>;
+        linkedAccounts: import("../api").LinkedAccount[];
+    }, Error, CreateAccountRequest, unknown>;
 };
 //# sourceMappingURL=useCreateAccount.d.ts.map

package/dist/src/hooks/useCreateAccount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCreateAccount.d.ts","sourceRoot":"","sources":["../../../src/hooks/useCreateAccount.ts"],"names":[],"mappings":"AAKA,wBAAgB,gBAAgB,CAAC,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBvD"}
+{"version":3,"file":"useCreateAccount.d.ts","sourceRoot":"","sources":["../../../src/hooks/useCreateAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EACf,YAAY,EACb,MAAM,uBAAuB,CAAA;AAG9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAA;AAEzE,wBAAgB,gBAAgB,CAC9B,eAAe,GAAE,IAAI,CACnB,eAAe,CAAC,qBAAqB,EAAE,YAAY,EAAE,oBAAoB,CAAC,EAC1E,YAAY,GAAG,aAAa,CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBP"}

package/dist/src/hooks/useCreateAccount.js

@@ -1,17 +1,20 @@
-import { useQueryClient, useMutation } from "@tanstack/react-query";
+import { useQueryClient, useMutation, } from "@tanstack/react-query";
 import { useAuthApiClient } from "./useAuthApiClient";
 import { QUERY_KEYS } from "./constants";
-export function useCreateAccount(useMutationOptions = {}) {
+export function useCreateAccount(mutationOptions = {}) {
     const queryClient = useQueryClient();
     const authApiClient = useAuthApiClient();
+    const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions;
     const { mutate, mutateAsync, ...rest } = useMutation({
         mutationFn: (createAccountRequest) => authApiClient.createAccount(createAccountRequest),
-        onSuccess: () => {
+        onSuccess: (data, variables, context) => {
             queryClient.resetQueries({
                 queryKey: [QUERY_KEYS.ACCOUNT],
             });
+            if (customOnSuccess)
+                customOnSuccess(data, variables, context);
         },
-        ...useMutationOptions,
+        ...restMutationOptions,
     });
     return { createAccount: mutate, createAccountAsync: mutateAsync, ...rest };
 }