@mezo-org/passport 0.4.0-dev.5 → 0.4.0-dev.50

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

@@ -1,4 +1,6 @@
-declare function useSignInWithWallet(): {
+import { MutationOptions } from "@tanstack/react-query";
+import type { Session } from "../api";
+declare function useSignInWithWallet(mutationOptions?: Omit<MutationOptions<Session>, "mutationFn" | "mutationKey">): {
     data: undefined;
     variables: undefined;
     error: null;
@@ -13,28 +15,8 @@ declare function useSignInWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 } | {
     data: undefined;
     variables: void;
@@ -50,28 +32,8 @@ declare function useSignInWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 } | {
     data: undefined;
     error: Error;
@@ -87,40 +49,10 @@ declare function useSignInWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 } | {
-    data: {
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    };
+    data: Session;
     error: null;
     variables: void;
     isError: false;
@@ -134,28 +66,8 @@ declare function useSignInWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signInWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signInWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 };
 export { useSignInWithWallet };
 //# sourceMappingURL=useSignInWithWallet.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSignInWithWallet.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSignInWithWallet.ts"],"names":[],"mappings":"AAEA,iBAAS,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}
+{"version":3,"file":"useSignInWithWallet.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSignInWithWallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAErC,iBAAS,mBAAmB,CAC1B,eAAe,GAAE,IAAI,CACnB,eAAe,CAAC,OAAO,CAAC,EACxB,YAAY,GAAG,aAAa,CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUP;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/src/hooks/useSignInWithWallet.js

@@ -1,6 +1,6 @@
 import { useAuthenticateWithWallet } from "./useAuthenticateWithWallet";
-function useSignInWithWallet() {
-    const { authenticateWithWallet, authenticateWithWalletAsync, ...rest } = useAuthenticateWithWallet();
+function useSignInWithWallet(mutationOptions = {}) {
+    const { authenticateWithWallet, authenticateWithWalletAsync, ...rest } = useAuthenticateWithWallet(false, mutationOptions);
     return {
         signInWithWallet: authenticateWithWallet,
         signInWithWalletAsync: authenticateWithWalletAsync,

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

@@ -1 +1 @@
-{"version":3,"file":"useSignInWithWallet.js","sourceRoot":"","sources":["../../../src/hooks/useSignInWithWallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,SAAS,mBAAmB;IAC1B,MAAM,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,GAAG,IAAI,EAAE,GACpE,yBAAyB,EAAE,CAAA;IAE7B,OAAO;QACL,gBAAgB,EAAE,sBAAsB;QACxC,qBAAqB,EAAE,2BAA2B;QAClD,GAAG,IAAI;KACR,CAAA;AACH,CAAC;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}
+{"version":3,"file":"useSignInWithWallet.js","sourceRoot":"","sources":["../../../src/hooks/useSignInWithWallet.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,SAAS,mBAAmB,CAC1B,kBAGI,EAAE;IAEN,MAAM,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,GAAG,IAAI,EAAE,GACpE,yBAAyB,CAAC,KAAK,EAAE,eAAe,CAAC,CAAA;IAEnD,OAAO;QACL,gBAAgB,EAAE,sBAAsB;QACxC,qBAAqB,EAAE,2BAA2B;QAClD,GAAG,IAAI;KACR,CAAA;AACH,CAAC;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

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

@@ -1,4 +1,6 @@
-export declare function useSignOut(useMutationOptions?: {}): {
+import { MutationOptions } from "@tanstack/react-query";
+import type { DeleteSessionResponse } from "../api";
+export declare function useSignOut(mutationOptions?: Omit<MutationOptions<DeleteSessionResponse>, "mutationFn" | "mutationKey">): {
     data: undefined;
     variables: undefined;
     error: null;
@@ -13,12 +15,8 @@ export declare function useSignOut(useMutationOptions?: {}): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signOut: import("@tanstack/react-query").UseMutateFunction<{
-        message: string;
-    }, Error, void, unknown>;
-    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        message: string;
-    }, Error, void, unknown>;
+    signOut: import("@tanstack/react-query").UseMutateFunction<DeleteSessionResponse, Error, void, unknown>;
+    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<DeleteSessionResponse, Error, void, unknown>;
 } | {
     data: undefined;
     variables: void;
@@ -34,12 +32,8 @@ export declare function useSignOut(useMutationOptions?: {}): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signOut: import("@tanstack/react-query").UseMutateFunction<{
-        message: string;
-    }, Error, void, unknown>;
-    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        message: string;
-    }, Error, void, unknown>;
+    signOut: import("@tanstack/react-query").UseMutateFunction<DeleteSessionResponse, Error, void, unknown>;
+    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<DeleteSessionResponse, Error, void, unknown>;
 } | {
     data: undefined;
     error: Error;
@@ -55,16 +49,10 @@ export declare function useSignOut(useMutationOptions?: {}): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signOut: import("@tanstack/react-query").UseMutateFunction<{
-        message: string;
-    }, Error, void, unknown>;
-    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        message: string;
-    }, Error, void, unknown>;
+    signOut: import("@tanstack/react-query").UseMutateFunction<DeleteSessionResponse, Error, void, unknown>;
+    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<DeleteSessionResponse, Error, void, unknown>;
 } | {
-    data: {
-        message: string;
-    };
+    data: DeleteSessionResponse;
     error: null;
     variables: void;
     isError: false;
@@ -78,11 +66,7 @@ export declare function useSignOut(useMutationOptions?: {}): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signOut: import("@tanstack/react-query").UseMutateFunction<{
-        message: string;
-    }, Error, void, unknown>;
-    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        message: string;
-    }, Error, void, unknown>;
+    signOut: import("@tanstack/react-query").UseMutateFunction<DeleteSessionResponse, Error, void, unknown>;
+    signOutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<DeleteSessionResponse, Error, void, unknown>;
 };
 //# sourceMappingURL=useSignOut.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSignOut.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSignOut.ts"],"names":[],"mappings":"AAIA,wBAAgB,UAAU,CAAC,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBjD"}
+{"version":3,"file":"useSignOut.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSignOut.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAGhB,MAAM,uBAAuB,CAAA;AAG9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAA;AAEnD,wBAAgB,UAAU,CACxB,eAAe,GAAE,IAAI,CACnB,eAAe,CAAC,qBAAqB,CAAC,EACtC,YAAY,GAAG,aAAa,CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBP"}

package/dist/src/hooks/useSignOut.js

@@ -1,18 +1,21 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useMutation, useQueryClient, } from "@tanstack/react-query";
 import { useAuthApiClient } from "./useAuthApiClient";
 import { QUERY_KEYS } from "./constants";
-export function useSignOut(useMutationOptions = {}) {
+export function useSignOut(mutationOptions = {}) {
     const queryClient = useQueryClient();
     const authApiClient = useAuthApiClient();
+    const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions;
     const { mutate, mutateAsync, ...rest } = useMutation({
         mutationFn: () => authApiClient.deleteSession(),
-        onSuccess: () => {
+        onSuccess: (data, variables, context) => {
             queryClient.resetQueries({ queryKey: [QUERY_KEYS.SESSION] });
             queryClient.resetQueries({
                 queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
             });
+            if (customOnSuccess)
+                customOnSuccess(data, variables, context);
         },
-        ...useMutationOptions,
+        ...restMutationOptions,
     });
     return { signOut: mutate, signOutAsync: mutateAsync, ...rest };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"useSignOut.js","sourceRoot":"","sources":["../../../src/hooks/useSignOut.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC,MAAM,UAAU,UAAU,CAAC,kBAAkB,GAAG,EAAE;IAChD,MAAM,WAAW,GAAG,cAAc,EAAE,CAAA;IACpC,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAA;IAExC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,GAAG,WAAW,CAAC;QACnD,UAAU,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,aAAa,EAAE;QAC/C,SAAS,EAAE,GAAG,EAAE;YACd,WAAW,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;YAC5D,WAAW,CAAC,YAAY,CAAC;gBACvB,QAAQ,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC;aACnD,CAAC,CAAA;QACJ,CAAC;QACD,GAAG,kBAAkB;KACtB,CAAC,CAAA;IAEF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,CAAA;AAChE,CAAC"}
+{"version":3,"file":"useSignOut.js","sourceRoot":"","sources":["../../../src/hooks/useSignOut.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EACX,cAAc,GACf,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAGxC,MAAM,UAAU,UAAU,CACxB,kBAGI,EAAE;IAEN,MAAM,WAAW,GAAG,cAAc,EAAE,CAAA;IACpC,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAA;IAExC,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,mBAAmB,EAAE,GAAG,eAAe,CAAA;IAE9E,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,GAAG,WAAW,CAAC;QACnD,UAAU,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,aAAa,EAAE;QAC/C,SAAS,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;YACtC,WAAW,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;YAC5D,WAAW,CAAC,YAAY,CAAC;gBACvB,QAAQ,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC;aACnD,CAAC,CAAA;YAEF,IAAI,eAAe;gBAAE,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAA;QAChE,CAAC;QACD,GAAG,mBAAmB;KACvB,CAAC,CAAA;IAEF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,CAAA;AAChE,CAAC"}

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

@@ -1,4 +1,6 @@
-declare function useSignUpWithWallet(): {
+import { MutationOptions } from "@tanstack/react-query";
+import type { Session } from "../api";
+declare function useSignUpWithWallet(mutationOptions?: Omit<MutationOptions<Session>, "mutationFn" | "mutationKey">): {
     data: undefined;
     variables: undefined;
     error: null;
@@ -13,28 +15,8 @@ declare function useSignUpWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 } | {
     data: undefined;
     variables: void;
@@ -50,28 +32,8 @@ declare function useSignUpWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 } | {
     data: undefined;
     error: Error;
@@ -87,40 +49,10 @@ declare function useSignUpWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 } | {
-    data: {
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    };
+    data: Session;
     error: null;
     variables: void;
     isError: false;
@@ -134,28 +66,8 @@ declare function useSignUpWithWallet(): {
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
-    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
-        expiresIn: number;
-        expiresAt: number;
-        sessionLinks: {
-            _links: {
-                account: "/session/account";
-            };
-        };
-    } | {
-        redirectTo: string;
-    }, Error, void, unknown>;
+    signUpWithWallet: import("@tanstack/react-query").UseMutateFunction<Session, Error, void, unknown>;
+    signUpWithWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Session, Error, void, unknown>;
 };
 export { useSignUpWithWallet };
 //# sourceMappingURL=useSignUpWithWallet.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSignUpWithWallet.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSignUpWithWallet.ts"],"names":[],"mappings":"AAEA,iBAAS,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}
+{"version":3,"file":"useSignUpWithWallet.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSignUpWithWallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAErC,iBAAS,mBAAmB,CAC1B,eAAe,GAAE,IAAI,CACnB,eAAe,CAAC,OAAO,CAAC,EACxB,YAAY,GAAG,aAAa,CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUP;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/src/hooks/useSignUpWithWallet.js

@@ -1,6 +1,6 @@
 import { useAuthenticateWithWallet } from "./useAuthenticateWithWallet";
-function useSignUpWithWallet() {
-    const { authenticateWithWallet, authenticateWithWalletAsync, ...rest } = useAuthenticateWithWallet({ signUp: true });
+function useSignUpWithWallet(mutationOptions = {}) {
+    const { authenticateWithWallet, authenticateWithWalletAsync, ...rest } = useAuthenticateWithWallet(true, mutationOptions);
     return {
         signUpWithWallet: authenticateWithWallet,
         signUpWithWalletAsync: authenticateWithWalletAsync,

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

@@ -1 +1 @@
-{"version":3,"file":"useSignUpWithWallet.js","sourceRoot":"","sources":["../../../src/hooks/useSignUpWithWallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,SAAS,mBAAmB;IAC1B,MAAM,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,GAAG,IAAI,EAAE,GACpE,yBAAyB,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;IAE7C,OAAO;QACL,gBAAgB,EAAE,sBAAsB;QACxC,qBAAqB,EAAE,2BAA2B;QAClD,GAAG,IAAI;KACR,CAAA;AACH,CAAC;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}
+{"version":3,"file":"useSignUpWithWallet.js","sourceRoot":"","sources":["../../../src/hooks/useSignUpWithWallet.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,SAAS,mBAAmB,CAC1B,kBAGI,EAAE;IAEN,MAAM,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,GAAG,IAAI,EAAE,GACpE,yBAAyB,CAAC,IAAI,EAAE,eAAe,CAAC,CAAA;IAElD,OAAO;QACL,gBAAgB,EAAE,sBAAsB;QACxC,qBAAqB,EAAE,2BAA2B;QAClD,GAAG,IAAI;KACR,CAAA;AACH,CAAC;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

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

@@ -0,0 +1,74 @@
+import { MezoChainToken } from "../lib/contracts";
+type UseMezoChainTokensBalancesOptions<T> = {
+    tokens?: T;
+    queryOptions?: object;
+};
+/**
+ * Hook to get the balance of a list of tokens for the current account
+ * @param   options.tokens The list of tokens to get the balance for. It will
+ *          fallback to all tokens if not provided.
+ * @param   options.queryOptions The query options to pass to the
+ *          `useReadContracts`
+ * @returns Tanstack's `useQuery` returnings with balance of tokens for the
+ *          current account in form of typesafe object with token names as keys
+ *          and balances as values.
+ * @dev     In case of error data fallbacks to `0n`. To determine if an error
+ *          occurred, check the `isError` property.
+ * @example
+ * const mezoTokensBalance = useTokensBalances({
+ *   tokens: ["mT", "mxSolvBTC"],
+ * })
+ * console.log(mezoTokensBalance?.data.mT) // Eg. 0n
+ * console.log(Object.keys(mezoTokensBalance?.data)) // ["mT", "mxSolvBTC"]
+ */
+export declare function useTokensBalances<T extends MezoChainToken[]>(options?: UseMezoChainTokensBalancesOptions<T>): import("wagmi").UseReadContractsReturnType<{
+    address: `0x${string}`;
+    abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "balanceOf";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    functionName: string;
+    args: `0x${string}`[];
+    chainId: number;
+}[], true, Record<T[number], bigint>>;
+/**
+ * Hook for invalidating current user's token balances. Can be used to
+ * invalidate the balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * invalidate query for.
+ * @returns Function `invalidateTokenBalances` that invalidates token balances
+ * @example
+ * const { invalidateTokenBalances } = useInvalidateTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await invalidateTokenBalances()
+ */
+export declare function useInvalidateTokensBalances(tokens?: MezoChainToken[]): {
+    invalidateTokensBalances: () => Promise<void>;
+};
+/**
+ * Hook for resetting current user's token balances. Can be used to reset the
+ * balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * reset query for.
+ * @returns Function `resetTokenBalances` that invalidates token balances
+ * @example
+ * const { resetTokenBalances } = useResetTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await resetTokenBalances()
+ */
+export declare function useResetTokensBalances(tokens?: MezoChainToken[]): {
+    resetTokenBalances: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useTokensBalances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTokensBalances.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTokensBalances.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,cAAc,EACf,MAAM,kBAAkB,CAAA;AA8CzB,KAAK,iCAAiC,CAAC,CAAC,IAAI;IAC1C,MAAM,CAAC,EAAE,CAAC,CAAA;IACV,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,cAAc,EAAE,EAC1D,OAAO,GAAE,iCAAiC,CAAC,CAAC,CAAM;;;;;;;;;;;;;;;;;;;;sCAuDnD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE;;EAapE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE;;EAa/D"}

package/dist/src/hooks/useTokensBalances.js

@@ -0,0 +1,140 @@
+import { useReadContracts } from "wagmi";
+import { useCallback, useMemo } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { usePassportContext } from "./usePassportContext";
+import { mainnetTokenContracts, testnetTokenContracts, } from "../lib/contracts";
+import useWalletAccount from "./useWalletAccount";
+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 BALANCE_OF_ABI = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+const BALANCE_TOKENS = [
+    "mcbBTC",
+    "mDAI",
+    "mFBTC",
+    "mSolvBTC",
+    "mswBTC",
+    "mT",
+    "mUSDC",
+    "mUSDe",
+    "mUSDT",
+    "mxSolvBTC",
+    "MUSD",
+];
+/**
+ * Hook to get the balance of a list of tokens for the current account
+ * @param   options.tokens The list of tokens to get the balance for. It will
+ *          fallback to all tokens if not provided.
+ * @param   options.queryOptions The query options to pass to the
+ *          `useReadContracts`
+ * @returns Tanstack's `useQuery` returnings with balance of tokens for the
+ *          current account in form of typesafe object with token names as keys
+ *          and balances as values.
+ * @dev     In case of error data fallbacks to `0n`. To determine if an error
+ *          occurred, check the `isError` property.
+ * @example
+ * const mezoTokensBalance = useTokensBalances({
+ *   tokens: ["mT", "mxSolvBTC"],
+ * })
+ * console.log(mezoTokensBalance?.data.mT) // Eg. 0n
+ * console.log(Object.keys(mezoTokensBalance?.data)) // ["mT", "mxSolvBTC"]
+ */
+export function useTokensBalances(options = {}) {
+    const { environment = "mainnet" } = usePassportContext();
+    const { accountAddress } = useWalletAccount();
+    const contractsMap = useMemo(() => {
+        const contracts = environment === "mainnet" ? mainnetTokenContracts : testnetTokenContracts;
+        const tokenContracts = Object.fromEntries(Object.entries(contracts).filter(([key]) => BALANCE_TOKENS.includes(key)));
+        return tokenContracts;
+    }, [environment]);
+    const { tokens = Object.keys(contractsMap), queryOptions = {} } = options;
+    const contracts = useMemo(() => {
+        if (!accountAddress)
+            return [];
+        return tokens.map((token) => {
+            const { address } = contractsMap[token];
+            return {
+                address,
+                abi: BALANCE_OF_ABI,
+                functionName: "balanceOf",
+                args: [accountAddress],
+                chainId: CHAIN_ID[environment],
+            };
+        });
+    }, [accountAddress, tokens, contractsMap, environment]);
+    return useReadContracts({
+        contracts,
+        query: {
+            select: (data) => data.reduce((acc, item) => {
+                const token = tokens[data.indexOf(item)];
+                return {
+                    ...acc,
+                    [token]: item.result ?? 0n,
+                };
+            }, {}),
+            ...queryOptions,
+        },
+    });
+}
+/**
+ * Hook for invalidating current user's token balances. Can be used to
+ * invalidate the balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * invalidate query for.
+ * @returns Function `invalidateTokenBalances` that invalidates token balances
+ * @example
+ * const { invalidateTokenBalances } = useInvalidateTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await invalidateTokenBalances()
+ */
+export function useInvalidateTokensBalances(tokens) {
+    const queryClient = useQueryClient();
+    const { queryKey } = useTokensBalances({ tokens });
+    const invalidateTokensBalancesHandler = useCallback(() => queryClient.invalidateQueries({ queryKey }), [queryClient, queryKey]);
+    return {
+        invalidateTokensBalances: invalidateTokensBalancesHandler,
+    };
+}
+/**
+ * Hook for resetting current user's token balances. Can be used to reset the
+ * balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * reset query for.
+ * @returns Function `resetTokenBalances` that invalidates token balances
+ * @example
+ * const { resetTokenBalances } = useResetTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await resetTokenBalances()
+ */
+export function useResetTokensBalances(tokens) {
+    const queryClient = useQueryClient();
+    const { queryKey } = useTokensBalances({ tokens });
+    const resetTokenBalancesHandler = useCallback(() => queryClient.resetQueries({ queryKey }), [queryClient, queryKey]);
+    return {
+        resetTokenBalances: resetTokenBalancesHandler,
+    };
+}
+//# sourceMappingURL=useTokensBalances.js.map