@rango-dev/widget-embedded 0.45.1-next.1 → 0.45.1-next.10

package/src/hooks/useStatefulConnect/useStatefulConnect.ts

@@ -7,6 +7,7 @@ import { WalletState } from '@rango-dev/ui';
 import { useWallets } from '@rango-dev/wallets-react';
 import { useReducer } from 'react';
 
+import { isOnDetached } from '../../components/StatefulConnectModal';
 import { type ExtendedModalWalletInfo } from '../../utils/wallets';
 
 import {
@@ -26,7 +27,7 @@ interface UseStatefulConnect {
     selectedNamespaces: Namespace[]
   ) => Promise<Result>;
   handleDerivationPath: (path: string) => Promise<Result>;
-  handleDisconnect: (type: WalletType) => Promise<Result>;
+  handleDisconnect: (wallet: WalletInfoWithExtra) => Promise<Result>;
   getState(): State;
   resetState(section?: 'derivation'): void;
 }
@@ -163,7 +164,7 @@ export function useStatefulConnect(): UseStatefulConnect {
     }
 
     if (options?.disconnectIfConnected) {
-      await handleDisconnect(wallet.type);
+      await handleDisconnect(wallet);
       return { status: ResultStatus.Disconnected };
     }
 
@@ -258,10 +259,25 @@ export function useStatefulConnect(): UseStatefulConnect {
     return await runConnect(type, namespaces);
   };
 
-  const handleDisconnect = async (type: WalletType): Promise<Result> => {
-    const wallet = state(type);
-    if (wallet.connected || wallet.connecting) {
-      await disconnect(type);
+  const getState = () => connectState;
+
+  const handleDisconnect = async (
+    wallet: ExtendedModalWalletInfo
+  ): Promise<Result> => {
+    const walletState = state(wallet.type);
+    if (walletState.connected || walletState.connecting) {
+      await disconnect(wallet.type);
+
+      if (isOnDetached(getState)) {
+        dispatch({
+          type: 'needsNamespace',
+          payload: {
+            targetWallet: wallet,
+          },
+        });
+        return { status: ResultStatus.Namespace };
+      }
+
       return { status: ResultStatus.Disconnected };
     }
 
@@ -273,7 +289,7 @@ export function useStatefulConnect(): UseStatefulConnect {
     handleDisconnect,
     handleNamespace,
     handleDerivationPath,
-    getState: () => connectState,
+    getState,
     resetState: (section?: 'derivation') => {
       if (section === 'derivation') {
         dispatch({

package/src/hooks/useSwapInput.ts

@@ -1,5 +1,6 @@
 import type { Token } from 'rango-sdk';
 
+import { warn } from '@rango-dev/logging-core';
 import { useCallback, useEffect, useRef, useState } from 'react';
 
 import { useAppStore } from '../store/AppStore';
@@ -168,16 +169,24 @@ export function useSwapInput({
           updateQuotePartialState('warning', quoteWarning);
         })
         .catch((error) => {
-          const { error: quoteError } = handleQuoteErrors(error);
+          const quoteError = handleQuoteErrors(error);
           if (
-            quoteError?.type === QuoteErrorType.NO_RESULT ||
-            quoteError?.type === QuoteErrorType.REQUEST_FAILED
+            quoteError.type === QuoteErrorType.NO_RESULT ||
+            quoteError.type === QuoteErrorType.REQUEST_FAILED
           ) {
             resetQuote();
           }
-          if (quoteError?.type !== QuoteErrorType.REQUEST_CANCELED) {
+
+          if (quoteError.type !== QuoteErrorType.REQUEST_CANCELED) {
             updateQuotePartialState('error', quoteError);
             setLoading(false);
+            warn(new Error('quote error'), {
+              tags: {
+                ...quoteError,
+                type: QuoteErrorType[quoteError.type],
+                requestBody,
+              },
+            });
           }
         });
     }

package/src/hooks/useWalletList.ts

@@ -78,7 +78,7 @@ export function useWalletList(params?: Params): API {
       wallets?.filter((wallet) => wallet.state === WalletState.CONNECTING) ||
       [];
     for (const wallet of connectingWallets) {
-      void handleDisconnect(wallet.type);
+      void handleDisconnect(wallet);
     }
   }, [hashWalletsState(wallets)]);
 

package/src/store/slices/wallets.ts

@@ -100,7 +100,11 @@ export interface WalletsSlice {
       namespaces?: Namespace[];
     }
   ) => void;
-  addConnectedWallet: (accounts: Wallet[], namespace?: Namespace) => void;
+  addConnectedWallet: (
+    accounts: Wallet[],
+    namespace?: Namespace,
+    derivationPath?: string
+  ) => void;
   setWalletsAsSelected: (
     wallets: { walletType: string; chain: string }[]
   ) => void;
@@ -109,7 +113,8 @@ export interface WalletsSlice {
    */
   newWalletConnected: (
     accounts: Wallet[],
-    namespace?: Namespace
+    namespace?: Namespace,
+    derivationPath?: string
   ) => Promise<void>;
   disconnectNamespaces: (walletType: string, namespaces: Namespace[]) => void;
   /**
@@ -231,7 +236,7 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
         };
       });
     },
-    addConnectedWallet: (accounts, namespace) => {
+    addConnectedWallet: (accounts, namespace, derivationPath) => {
       /*
        * When we are going to add a new account, there are two thing that can be happens:
        * 1. Wallet hasn't add yet.
@@ -276,6 +281,7 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
               walletType: account.walletType,
               selected: shouldMarkWalletAsSelected,
               namespace: namespace,
+              derivationPath: derivationPath,
               loading: false,
               error: false,
             };
@@ -435,13 +441,13 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
         connectedWallets: nextConnectedWalletsWithUpdatedSelectedStatus,
       });
     },
-    newWalletConnected: async (accounts, namespace) => {
+    newWalletConnected: async (accounts, namespace, derivationPath) => {
       eventEmitter.emit(WidgetEvents.WalletEvent, {
         type: WalletEventTypes.CONNECT,
         payload: { walletType: accounts[0].walletType, accounts },
       });
 
-      get().addConnectedWallet(accounts, namespace);
+      get().addConnectedWallet(accounts, namespace, derivationPath);
 
       void get().fetchBalances(accounts);
     },

package/src/types/quote.ts

@@ -57,7 +57,7 @@ export enum QuoteWarningType {
   EXCESSIVE_OUTPUT_AMOUNT_CHANGE,
 }
 
-export type RecommendedSlippages = Map<number, string>;
+export type RecommendedSlippages = Record<number, string>;
 
 export type InsufficientSlippageWarning = {
   type: QuoteWarningType.INSUFFICIENT_SLIPPAGE;

package/src/types/wallets.ts

@@ -6,6 +6,7 @@ export interface Wallet {
   address: string;
   walletType: WalletType;
   isContractWallet?: boolean;
+  derivationPath?: string;
 }
 
 export type Balance = {

package/src/utils/swap.ts

@@ -353,14 +353,14 @@ export function hasSlippageError(
 export function checkSlippageErrors(
   swaps: SwapResult[]
 ): RecommendedSlippages | null {
-  const recommendedSlippages: RecommendedSlippages = new Map();
+  const recommendedSlippages = new Map<number, string>();
   swaps.forEach((swap, index) => {
     if (swap.recommendedSlippage?.error) {
       recommendedSlippages.set(index, swap.recommendedSlippage.slippage);
     }
   });
   if (recommendedSlippages.size > 0) {
-    return recommendedSlippages;
+    return Object.fromEntries(recommendedSlippages);
   }
   return null;
 }
@@ -369,7 +369,7 @@ export function checkSlippageWarnings(
   quote: SelectedQuote,
   userSlippage: number
 ): RecommendedSlippages | null {
-  const recommendedSlippages: RecommendedSlippages = new Map();
+  const recommendedSlippages = new Map<number, string>();
   quote?.swaps.forEach((swap, index) => {
     if (
       swap.recommendedSlippage?.slippage &&
@@ -379,7 +379,7 @@ export function checkSlippageWarnings(
     }
   });
   if (recommendedSlippages.size > 0) {
-    return recommendedSlippages;
+    return Object.fromEntries(recommendedSlippages);
   }
   return null;
 }
@@ -534,13 +534,18 @@ export function getWalletsForNewSwap(selectedWallets: Wallet[]) {
   const wallets = selectedWallets.reduce(
     (
       selectedWalletsMap: {
-        [p: string]: { address: string; walletType: WalletType };
+        [p: string]: {
+          address: string;
+          walletType: WalletType;
+          derivationPath?: string;
+        };
       },
       selectedWallet
     ) => (
       (selectedWalletsMap[selectedWallet.chain] = {
         address: selectedWallet.address,
         walletType: selectedWallet.walletType,
+        derivationPath: selectedWallet.derivationPath,
       }),
       selectedWalletsMap
     ),

package/dist/components/SwapDetailsModal/SwapDetailsModal.helpers.d.ts

@@ -1,4 +0,0 @@
-import type { ModalNetworkValueTypes } from './SwapDetailsModal.types';
-import { PendingSwapNetworkStatus } from 'rango-types';
-export declare const modalNetworkValues: Record<Exclude<PendingSwapNetworkStatus, PendingSwapNetworkStatus.WaitingForQueue>, ModalNetworkValueTypes>;
-//# sourceMappingURL=SwapDetailsModal.helpers.d.ts.map

package/dist/components/SwapDetailsModal/SwapDetailsModal.helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwapDetailsModal.helpers.d.ts","sourceRoot":"","sources":["../../../src/components/SwapDetailsModal/SwapDetailsModal.helpers.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEvD,eAAO,MAAM,kBAAkB,EAAE,MAAM,CACrC,OAAO,CAAC,wBAAwB,EAAE,wBAAwB,CAAC,eAAe,CAAC,EAC3E,sBAAsB,CAkBvB,CAAC"}

package/dist/components/WalletStatefulConnect/NamespaceUnsupportedItem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NamespaceUnsupportedItem.d.ts","sourceRoot":"","sources":["../../../src/components/WalletStatefulConnect/NamespaceUnsupportedItem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AAI5E,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,iCAAiC,qBAwBzC"}

package/dist/components/WalletStatefulConnect/Namespaces.helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Namespaces.helpers.d.ts","sourceRoot":"","sources":["../../../src/components/WalletStatefulConnect/Namespaces.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,cAAc,EAAE,EAC7B,cAAc,EAAE,MAAM,sBAIvB"}

package/dist/components/WalletStatefulConnect/SupportedChainsList.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SupportedChainsList.d.ts","sourceRoot":"","sources":["../../../src/components/WalletStatefulConnect/SupportedChainsList.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAG7D,OAAO,KAAK,MAAM,OAAO,CAAC;AAW1B,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,qBA2CnD"}

package/dist/components/WalletStatefulConnect/SupportedChainsList.styles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SupportedChainsList.styles.d.ts","sourceRoot":"","sources":["../../../src/components/WalletStatefulConnect/SupportedChainsList.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAKnC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAe7B,CAAC"}

package/dist/components/WalletStatefulConnect/SupportedChainsList.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SupportedChainsList.types.d.ts","sourceRoot":"","sources":["../../../src/components/WalletStatefulConnect/SupportedChainsList.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC"}

package/src/components/SwapDetailsModal/SwapDetailsModal.helpers.tsx

@@ -1,26 +0,0 @@
-import type { ModalNetworkValueTypes } from './SwapDetailsModal.types';
-
-import { i18n } from '@lingui/core';
-import { PendingSwapNetworkStatus } from 'rango-types';
-
-export const modalNetworkValues: Record<
-  Exclude<PendingSwapNetworkStatus, PendingSwapNetworkStatus.WaitingForQueue>,
-  ModalNetworkValueTypes
-> = {
-  [PendingSwapNetworkStatus.WaitingForNetworkChange]: {
-    type: 'loading',
-    title: i18n.t('Change Network'),
-  },
-  [PendingSwapNetworkStatus.WaitingForConnectingWallet]: {
-    type: 'warning',
-    title: i18n.t('Connect Wallet'),
-  },
-  [PendingSwapNetworkStatus.NetworkChanged]: {
-    type: 'success',
-    title: i18n.t('Network Changed'),
-  },
-  [PendingSwapNetworkStatus.NetworkChangeFailed]: {
-    type: 'warning',
-    title: i18n.t('Network Change Failed'),
-  },
-};