@sundaeswap/wallet-lite 0.0.84 → 0.0.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/wallet-lite",
-  "version": "0.0.84",
+  "version": "0.0.85",
   "license": "MIT",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/classes/WalletObserver.class.ts

@@ -136,7 +136,6 @@ export class WalletObserver<
 
         if (newNetwork instanceof Error) {
           this.dispatch(EWalletObserverEvents.SYNCING_WALLET_END);
-          this.dispatch(EWalletObserverEvents.CONNECT_WALLET_END);
           this._performingSync = false;
           throw newNetwork;
         }
@@ -177,16 +176,11 @@ export class WalletObserver<
         ...result,
         activeWallet: this.activeWallet!,
       });
-      this.dispatch(EWalletObserverEvents.CONNECT_WALLET_END, {
-        ...result,
-        activeWallet: this.activeWallet!,
-      });
       this._performingSync = false;
       return result;
     } catch (e) {
       this._performingSync = false;
       this.dispatch(EWalletObserverEvents.SYNCING_WALLET_END);
-      this.dispatch(EWalletObserverEvents.CONNECT_WALLET_END);
       throw e;
     }
   };
@@ -285,9 +279,11 @@ export class WalletObserver<
    * 10 seconds before throw an error.
    *
    * @param {string} extension The name of the extension to enable.
-   * @return {Promise<void>}
+   * @return {Promise<IWalletObserverSync<AssetMetadata> | Error>}
    */
-  connectWallet = async (extension: string): Promise<void> => {
+  connectWallet = async (
+    extension: string,
+  ): Promise<IWalletObserverSync<AssetMetadata> | Error> => {
     const start = performance.now();
     this.dispatch(EWalletObserverEvents.CONNECT_WALLET_START);
 
@@ -312,23 +308,24 @@ export class WalletObserver<
     }
 
     if (!extensionObject) {
+      this.dispatch(EWalletObserverEvents.CONNECT_WALLET_END);
       throw new Error("Wallet extension not found in the global context.");
     }
 
-    const api = await this.syncApi(extension);
-
     this.activeWallet = extension;
-    if (this._options.persistence && api) {
-      const addresses = await this.getUsedAddresses();
-      if (addresses instanceof Error) {
-        addresses.cause =
+    await this.syncApi(extension);
+    const data = await this.sync();
+
+    if (this._options.persistence) {
+      if (data.usedAddresses instanceof Error) {
+        data.usedAddresses.cause =
           "Could not get a list of used addresses from the wallet when trying to save the connection.";
-        throw addresses;
+        throw data.usedAddresses;
       }
 
       const seed: IWalletObserverSeed = {
         activeWallet: extension,
-        mainAddress: addresses[0],
+        mainAddress: data.usedAddresses[0],
       };
 
       window.localStorage.setItem(
@@ -337,10 +334,16 @@ export class WalletObserver<
       );
     }
 
+    this.dispatch(EWalletObserverEvents.CONNECT_WALLET_END, {
+      ...data,
+      activeWallet: extension,
+    });
     const end = performance.now();
     if (this._options.debug) {
       console.log(`connectWallet: ${end - start}ms`);
     }
+
+    return data;
   };
 
   getCip45Instance = async () => {

package/src/classes/__tests__/WalletObserver.test.ts

@@ -241,6 +241,10 @@ describe("WalletObserver", async () => {
       ).toBeNull();
       expect(spiedDispatch).toHaveBeenNthCalledWith(
         7,
+        EWalletObserverEvents.SYNCING_WALLET_START,
+      );
+      expect(spiedDispatch).toHaveBeenNthCalledWith(
+        11,
         EWalletObserverEvents.DISCONNECT,
       );
       expect(spiedOnGetPeerConnect).not.toHaveBeenCalled();

package/src/react-components/WalletObserverProvider/WalletObserverProvider.tsx

@@ -27,7 +27,7 @@ const WalletObserverProvider: FC<
     syncingWallet,
     ready,
     eventListenersAttached,
-  } = useProviderWalletObserverRef(options?.observerOptions);
+  } = useProviderWalletObserverRef(options?.observerOptions, options?.hooks);
   const state = useWalletObserverState(observerRef.current);
 
   useProviderRefreshInterval(

package/src/react-components/WalletObserverProvider/hooks/useProviderWalletObserverRef.ts

@@ -49,32 +49,42 @@ export const useProviderWalletObserverRef = (
       return;
     }
 
-    const setConnectingStart = async () => {
-      setConnecting(() => true);
-      await hooks?.onConnectWalletStart?.();
+    const setConnectingStart = () => {
+      (async () => {
+        setConnecting(() => true);
+        await hooks?.onConnectWalletStart?.();
+      })().catch(console.error);
     };
-    const setConnectingEnd = async (
+    const setConnectingEnd = (
       data?: IWalletObserverSync<IAssetAmountMetadata> & {
         activeWallet: string;
       },
     ) => {
-      setConnecting(() => false);
-      await hooks?.onConnectWalletEnd?.(data);
+      (async () => {
+        setConnecting(() => false);
+        await hooks?.onConnectWalletEnd?.(data);
+      })().catch(console.error);
     };
-    const setSyncingStart = async () => {
-      setSyncing(() => true);
-      await hooks?.onSyncWalletStart?.();
+    const setSyncingStart = () => {
+      (async () => {
+        setSyncing(() => true);
+        await hooks?.onSyncWalletStart?.();
+      })().catch(console.error);
     };
-    const setSyncingEnd = async (
+    const setSyncingEnd = (
       data?: IWalletObserverSync<IAssetAmountMetadata> & {
         activeWallet: string;
       },
     ) => {
-      await hooks?.onSyncWalletEnd?.(data);
-      setSyncing(() => false);
+      (async () => {
+        await hooks?.onSyncWalletEnd?.(data);
+        setSyncing(() => false);
+      })().catch(console.error);
     };
     const onDisconnect = () => {
-      hooks?.onDisconnectWallet?.();
+      (async () => {
+        hooks?.onDisconnectWallet?.();
+      })().catch(console.error);
     };
 
     observerRef.current.addEventListener(

package/src/react-components/WalletObserverProvider/hooks/useWalletObserverState.ts

@@ -2,6 +2,7 @@ import type { TransactionUnspentOutput } from "@cardano-sdk/core/dist/cjs/Serial
 import { AssetAmount, IAssetAmountMetadata } from "@sundaeswap/asset";
 import { useCallback, useEffect, useState, useTransition } from "react";
 
+import { IWalletObserverSync } from "src/@types/observer.js";
 import { WalletBalanceMap } from "../../../classes/WalletBalanceMap.class.js";
 import { WalletObserver } from "../../../classes/WalletObserver.class.js";
 import { ADA_ASSET_ID } from "../../../constants.js";
@@ -66,127 +67,131 @@ export const useWalletObserverState = <
         setSwitching(() => true);
       }
 
-      await observer.connectWallet(wallet);
-      await syncWallet();
+      const data = await observer.connectWallet(wallet);
+      await syncWallet(data instanceof Error ? undefined : data);
       setSwitching(() => false);
       return observer.api;
     },
     [observer, setSwitching],
   );
 
-  const syncWallet = useCallback(async () => {
-    if (observer.isSyncing() || !observer.hasActiveConnection()) {
-      return;
-    }
-
-    const newWallet = observer.activeWallet;
-    if (!newWallet) {
-      disconnect();
-      return;
-    }
-
-    setIsCip45(newWallet.includes("p2p"));
-    setActiveWallet((prevWallet) =>
-      newWallet === prevWallet ? prevWallet : newWallet,
-    );
-
-    try {
-      const freshData = await observer.sync();
-
-      startTransition(() => {
-        const newBalanceMap = freshData.balanceMap;
-        if (newBalanceMap instanceof WalletBalanceMap) {
-          const newAdaBalance = newBalanceMap.get(ADA_ASSET_ID);
-          if (newAdaBalance) {
-            setAdaBalance((prevBalance) =>
-              prevBalance.amount === newAdaBalance.amount
-                ? prevBalance
-                : newAdaBalance,
+  const syncWallet = useCallback(
+    async (importedData?: IWalletObserverSync<AssetMetadata> | undefined) => {
+      if (observer.isSyncing() || !observer.hasActiveConnection()) {
+        return;
+      }
+
+      const newWallet = observer.activeWallet;
+      if (!newWallet) {
+        disconnect();
+        return;
+      }
+
+      setIsCip45(newWallet.includes("p2p"));
+      setActiveWallet((prevWallet) =>
+        newWallet === prevWallet ? prevWallet : newWallet,
+      );
+
+      try {
+        const freshData = importedData || (await observer.sync());
+
+        startTransition(() => {
+          const newBalanceMap = freshData.balanceMap;
+          if (newBalanceMap instanceof WalletBalanceMap) {
+            const newAdaBalance = newBalanceMap.get(ADA_ASSET_ID);
+            if (newAdaBalance) {
+              setAdaBalance((prevBalance) =>
+                prevBalance.amount === newAdaBalance.amount
+                  ? prevBalance
+                  : newAdaBalance,
+              );
+
+              setBalance((prevBalance) =>
+                areAssetMapsEqual(prevBalance, newBalanceMap)
+                  ? prevBalance
+                  : newBalanceMap,
+              );
+            }
+          }
+
+          const newUsedAddresses = freshData.usedAddresses;
+          if (newUsedAddresses instanceof Array) {
+            setUsedAddresses((prevValue) => {
+              return JSON.stringify(prevValue) ===
+                JSON.stringify(newUsedAddresses)
+                ? prevValue
+                : newUsedAddresses;
+            });
+          }
+
+          const newUnusedAddresses = freshData.unusedAddresses;
+          if (newUnusedAddresses instanceof Array) {
+            setUnusedAddresses((prevValue) =>
+              JSON.stringify(prevValue) === JSON.stringify(newUnusedAddresses)
+                ? prevValue
+                : newUnusedAddresses,
             );
+          }
 
-            setBalance((prevBalance) =>
-              areAssetMapsEqual(prevBalance, newBalanceMap)
-                ? prevBalance
-                : newBalanceMap,
+          const newNetwork = freshData.network;
+          if (typeof newNetwork === "number") {
+            setNetwork((prevValue) =>
+              prevValue === newNetwork ? prevValue : newNetwork,
             );
           }
-        }
-
-        const newUsedAddresses = freshData.usedAddresses;
-        if (newUsedAddresses instanceof Array) {
-          setUsedAddresses((prevValue) => {
-            return JSON.stringify(prevValue) ===
-              JSON.stringify(newUsedAddresses)
-              ? prevValue
-              : newUsedAddresses;
-          });
-        }
-
-        const newUnusedAddresses = freshData.unusedAddresses;
-        if (newUnusedAddresses instanceof Array) {
-          setUnusedAddresses((prevValue) =>
-            JSON.stringify(prevValue) === JSON.stringify(newUnusedAddresses)
-              ? prevValue
-              : newUnusedAddresses,
-          );
-        }
-
-        const newNetwork = freshData.network;
-        if (typeof newNetwork === "number") {
-          setNetwork((prevValue) =>
-            prevValue === newNetwork ? prevValue : newNetwork,
-          );
-        }
-
-        const newUtxos = freshData.utxos;
-        if (newUtxos instanceof Array) {
-          setUtxos((prevValue) => {
-            const prevValueRep = prevValue?.map((v) => v.toCbor());
-            const newValueRep = newUtxos?.map((v) => v.toCbor());
-            if (prevValueRep !== newValueRep) {
-              return newUtxos;
-            }
 
-            return prevValue;
-          });
-        }
-
-        const newCollateral = freshData.collateral;
-        if (newCollateral instanceof Array) {
-          setCollateral((prevValue) => {
-            const prevValueRep = prevValue?.map((v) => v.toCbor());
-            const newValueRep = newCollateral?.map((v) => v.toCbor());
-            if (prevValueRep !== newValueRep) {
-              return newCollateral;
-            }
+          const newUtxos = freshData.utxos;
+          if (newUtxos instanceof Array) {
+            setUtxos((prevValue) => {
+              const prevValueRep = prevValue?.map((v) => v.toCbor());
+              const newValueRep = newUtxos?.map((v) => v.toCbor());
+              if (prevValueRep !== newValueRep) {
+                return newUtxos;
+              }
+
+              return prevValue;
+            });
+          }
+
+          const newCollateral = freshData.collateral;
+          if (newCollateral instanceof Array) {
+            setCollateral((prevValue) => {
+              const prevValueRep = prevValue?.map((v) => v.toCbor());
+              const newValueRep = newCollateral?.map((v) => v.toCbor());
+              if (prevValueRep !== newValueRep) {
+                return newCollateral;
+              }
+
+              return prevValue;
+            });
+          }
 
-            return prevValue;
-          });
-        }
-
-        const newFeeAddress = freshData.feeAddress;
-        if (typeof newFeeAddress === "string") {
-          setFeeAddress((prevValue) =>
-            prevValue === newFeeAddress ? prevValue : newFeeAddress,
-          );
-        }
-      });
-    } catch (e) {
-      setErrorSyncing(true);
-      (e as Error).cause =
-        "The wallet threw an error while the app was trying to sync with it. Please try again or contact your wallet provider.";
-      throw e;
-    }
-  }, [observer, disconnect]);
+          const newFeeAddress = freshData.feeAddress;
+          if (typeof newFeeAddress === "string") {
+            setFeeAddress((prevValue) =>
+              prevValue === newFeeAddress ? prevValue : newFeeAddress,
+            );
+          }
+        });
+      } catch (e) {
+        setErrorSyncing(true);
+        (e as Error).cause =
+          "The wallet threw an error while the app was trying to sync with it. Please try again or contact your wallet provider.";
+        throw e;
+      }
+    },
+    [observer, disconnect],
+  );
 
   /**
    * Ensure the wallet syncs on connect and disconnect.
    */
   useEffect(() => {
-    window.addEventListener("focus", syncWallet);
+    const func = () => syncWallet();
+    window.addEventListener("focus", func);
 
     return () => {
-      window.addEventListener("focus", syncWallet);
+      window.addEventListener("focus", func);
     };
   }, [syncWallet]);