@swype-org/react-sdk 0.1.272 → 0.1.280

package/dist/index.cjs

@@ -1856,6 +1856,17 @@ function effectiveMinTransferAmountUsd(depositAmount) {
 }
 function persistMobileFlowState(data) {
   try {
+    console.info("[blink-sdk] persistMobileFlowState", {
+      isGuestPreauth: data.isGuestPreauth ?? false,
+      isGuestCheckout: data.isGuestCheckout ?? false,
+      isReauthorization: data.isReauthorization ?? false,
+      isSetup: data.isSetup,
+      hasGuestSessionToken: !!data.guestSessionToken,
+      hasSessionId: !!data.sessionId,
+      hasAccountId: !!data.accountId,
+      hasTransferId: !!data.transferId,
+      caller: new Error().stack?.split("\n")[2]?.trim()
+    });
     sessionStorage.setItem(MOBILE_FLOW_STORAGE_KEY, JSON.stringify(data));
   } catch {
   }
@@ -1871,6 +1882,10 @@ function loadMobileFlowState() {
 }
 function clearMobileFlowState() {
   try {
+    console.info("[blink-sdk] clearMobileFlowState", {
+      hadState: sessionStorage.getItem(MOBILE_FLOW_STORAGE_KEY) != null,
+      caller: new Error().stack?.split("\n")[2]?.trim()
+    });
     sessionStorage.removeItem(MOBILE_FLOW_STORAGE_KEY);
   } catch {
   }
@@ -2196,6 +2211,25 @@ function resolvePhase(state) {
   } else {
     nextPhase = { step: "wallet-picker", reason: "entry" };
   }
+  if (state.guestPreauthSessionId != null) {
+    console.info("[blink-sdk] resolvePhase (guest preauth context)", {
+      resolvedStep: nextPhase.step,
+      currentStep: currentPhase.step,
+      branchGuestPostPayLogin,
+      branchMobileWalletSetup,
+      branchLoginRequested,
+      branchCompleted,
+      branchKeepGuestPreauthPin,
+      branchGuestSetupComplete,
+      transferStatus: state.transfer?.status ?? null,
+      mobileFlow: state.mobileFlow,
+      deeplinkUri: state.deeplinkUri != null,
+      loginRequested: state.loginRequested,
+      guestPreauthorizing: state.guestPreauthorizing,
+      privyAuthenticated: state.privyAuthenticated,
+      isGuestFlow: state.isGuestFlow
+    });
+  }
   return nextPhase;
 }
 
@@ -2263,6 +2297,30 @@ function paymentReducer(state, action) {
       loginRequested: next.loginRequested
     });
   }
+  if (action.type === "REQUEST_LOGIN") {
+    console.info("[blink-sdk] reducer REQUEST_LOGIN", {
+      resolvedPhase: phase.step,
+      mobileFlow: next.mobileFlow,
+      loginRequested: next.loginRequested,
+      guestPreauthSessionId: next.guestPreauthSessionId,
+      guestPreauthAccountId: next.guestPreauthAccountId,
+      transferStatus: next.transfer?.status ?? null,
+      isGuestFlow: next.isGuestFlow,
+      privyReady: next.privyReady,
+      privyAuthenticated: next.privyAuthenticated
+    });
+  }
+  if (action.type === "MOBILE_SETUP_COMPLETE") {
+    console.info("[blink-sdk] reducer MOBILE_SETUP_COMPLETE", {
+      resolvedPhase: phase.step,
+      mobileFlow: next.mobileFlow,
+      deeplinkUri: next.deeplinkUri,
+      loginRequested: next.loginRequested,
+      guestPreauthSessionId: next.guestPreauthSessionId,
+      transferStatus: next.transfer?.status ?? null,
+      isGuestFlow: next.isGuestFlow
+    });
+  }
   return { ...next, phase };
 }
 function applyAction(state, action) {
@@ -2413,7 +2471,12 @@ function applyAction(state, action) {
       return {
         ...state,
         mobileFlow: true,
-        deeplinkUri: action.deeplinkUri
+        deeplinkUri: action.deeplinkUri,
+        ...action.guestTransferId != null && {
+          guestTransferId: action.guestTransferId,
+          guestSessionToken: action.guestSessionToken ?? null,
+          isGuestFlow: true
+        }
       };
     case "MOBILE_SETUP_COMPLETE":
       return {
@@ -2531,6 +2594,7 @@ function applyAction(state, action) {
         mobileFlow: false,
         deeplinkUri: null,
         isGuestFlow: true,
+        guestTransferId: null,
         guestSessionToken: action.guestSessionToken ?? state.guestSessionToken
       };
     case "GUEST_PREAUTH_DETECTED":
@@ -6280,6 +6344,7 @@ function StepRendererContent({
   const {
     pollingTransfer,
     pollingError,
+    guestAccountPollingError,
     authExecutorError,
     transferSigningSigning,
     transferSigningError,
@@ -6395,7 +6460,7 @@ function StepRendererContent({
           deeplinkUri: state.deeplinkUri ?? "",
           loading: !isDesktop ? state.creatingTransfer || !state.deeplinkUri : state.creatingTransfer,
           useDeeplink: !isDesktop,
-          error: state.error || (!isDesktop ? pollingError : authExecutorError),
+          error: state.error || guestAccountPollingError || (!isDesktop ? pollingError : authExecutorError),
           onRetryStatus: !isDesktop ? handlers.onRetryMobileStatus : void 0,
           onBack: !isDesktop ? handlers.onBackFromOpenWallet : void 0,
           onLogout: handlers.onLogout
@@ -7199,7 +7264,7 @@ function useSourceSelectionHandlers(dispatch, authExecutor, options) {
     initializedSelectSourceActionRef
   };
 }
-function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransferIdRef, stateTransfer, refs, onComplete) {
+function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransferIdRef, stateTransfer, refs, guestCheckout, onComplete) {
   const {
     mobileSetupFlowRef,
     handlingMobileReturnRef,
@@ -7210,6 +7275,10 @@ function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransfe
   onCompleteRef.current = onComplete;
   const guestPollingActiveRef = react.useRef(false);
   const guestPollingCleanupRef = react.useRef(null);
+  const guestTransferIdRef = react.useRef(guestCheckout.guestTransferId);
+  guestTransferIdRef.current = guestCheckout.guestTransferId;
+  const guestSessionTokenRef = react.useRef(guestCheckout.guestSessionToken);
+  guestSessionTokenRef.current = guestCheckout.guestSessionToken;
   const startGuestPolling = react.useCallback((transferId, guestSessionToken) => {
     if (guestPollingActiveRef.current) return;
     guestPollingActiveRef.current = true;
@@ -7225,14 +7294,12 @@ function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransfe
           cancelled = true;
           guestPollingActiveRef.current = false;
           guestPollingCleanupRef.current = null;
-          clearMobileFlowState();
           dispatch({ type: "GUEST_TRANSFER_COMPLETED", transfer, guestSessionToken });
           onCompleteRef.current?.(transfer);
         } else if (transfer.status === "FAILED") {
           cancelled = true;
           guestPollingActiveRef.current = false;
           guestPollingCleanupRef.current = null;
-          clearMobileFlowState();
           dispatch({ type: "TRANSFER_FAILED", transfer, error: "Transfer failed." });
         }
       } catch {
@@ -7249,20 +7316,26 @@ function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransfe
     guestPollingCleanupRef.current = cleanup;
   }, [apiBaseUrl, dispatch]);
   react.useEffect(() => {
-    const persisted = loadMobileFlowState();
-    if (persisted?.isGuestCheckout && persisted.transferId && persisted.guestSessionToken) {
-      startGuestPolling(persisted.transferId, persisted.guestSessionToken);
+    if (guestCheckout.mobileFlow && guestCheckout.isGuestFlow && guestCheckout.guestTransferId && guestCheckout.guestSessionToken) {
+      startGuestPolling(guestCheckout.guestTransferId, guestCheckout.guestSessionToken);
     }
     return () => {
       guestPollingCleanupRef.current?.();
     };
-  }, [startGuestPolling]);
+  }, [
+    guestCheckout.mobileFlow,
+    guestCheckout.isGuestFlow,
+    guestCheckout.guestTransferId,
+    guestCheckout.guestSessionToken,
+    startGuestPolling
+  ]);
   react.useEffect(() => {
     const tryStartPolling = () => {
       if (guestPollingActiveRef.current) return;
-      const persisted = loadMobileFlowState();
-      if (persisted?.isGuestCheckout && persisted.transferId && persisted.guestSessionToken) {
-        startGuestPolling(persisted.transferId, persisted.guestSessionToken);
+      const transferId = guestTransferIdRef.current;
+      const token = guestSessionTokenRef.current;
+      if (transferId && token) {
+        startGuestPolling(transferId, token);
       }
     };
     const handleVisibility = () => {
@@ -7406,16 +7479,13 @@ function useProviderHandlers(deps) {
           dispatch({ type: "PAY_ERROR", error: "This wallet is not available on mobile." });
           return;
         }
-        persistMobileFlowState({
-          transferId: result.id,
-          guestSessionToken: result.guestSessionToken,
-          isGuestCheckout: true,
+        triggerDeeplink(result.uri);
+        dispatch({
+          type: "MOBILE_DEEPLINK_READY",
           deeplinkUri: result.uri,
-          providerId,
-          isSetup: false
+          guestTransferId: result.id,
+          guestSessionToken: result.guestSessionToken
         });
-        triggerDeeplink(result.uri);
-        dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: result.uri });
       } else {
         const account = getAccount(wagmiConfig2);
         if (!account.isConnected) {
@@ -7751,6 +7821,14 @@ function useProviderHandlers(deps) {
       useWalletConnector: useWalletConnectorProp,
       userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
     });
+    console.info("[blink-sdk] handlePreauthorize", {
+      isMobile,
+      useWalletConnectorProp,
+      hasGuestSessionToken: !!guestSessionToken,
+      selectedProviderId,
+      guestTransferId,
+      userAgent: typeof navigator === "undefined" ? null : navigator.userAgent
+    });
     const providerName = providers.find((p) => p.id === selectedProviderId)?.name ?? "Wallet";
     if (!isMobile) {
       dispatch({ type: "GUEST_PREAUTH_BEGIN" });
@@ -8172,7 +8250,8 @@ function usePasskeyCheckEffect(deps) {
     setupAccountIdRef,
     reauthSessionIdRef,
     reauthTokenRef,
-    pollingTransferIdRef
+    pollingTransferIdRef,
+    startGuestAccountPolling
   } = deps;
   const { getAccessToken } = reactAuth.usePrivy();
   const onCompleteRef = react.useRef(deps.onComplete);
@@ -8195,8 +8274,23 @@ function usePasskeyCheckEffect(deps) {
     dispatch({ type: "SET_ERROR", error: null });
     setAuthInput("");
     setOtpCode("");
+    const startGuestAccountPollingRef = startGuestAccountPolling;
     const restoreState = async (credId, token) => {
       const persisted = loadMobileFlowState();
+      if (persisted?.isGuestPreauth && persisted.guestSessionToken && persisted.sessionId) {
+        mobileSetupFlowRef.current = true;
+        if (persisted.accountId) {
+          setupAccountIdRef.current = persisted.accountId;
+          dispatch({
+            type: "GUEST_PREAUTH_DETECTED",
+            accountId: persisted.accountId,
+            sessionId: persisted.sessionId
+          });
+        }
+        dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: persisted.deeplinkUri });
+        startGuestAccountPollingRef(persisted.guestSessionToken, persisted.sessionId);
+        return;
+      }
       let accts = [];
       try {
         accts = await fetchAccounts(apiBaseUrl, token, credId);
@@ -8845,10 +8939,24 @@ function useGuestPreauthMobileRestoreEffect(deps) {
   } = deps;
   const startedRef = react.useRef(false);
   react.useEffect(() => {
-    if (!privyReady) return;
-    const tryStart = () => {
-      if (startedRef.current) return;
+    if (!privyReady) {
+      console.info("[blink-sdk] guestPreauthMobileRestore: skipping, privyReady=false");
+      return;
+    }
+    const tryStart = (trigger) => {
+      if (startedRef.current) {
+        console.info("[blink-sdk] guestPreauthMobileRestore.tryStart: already started", { trigger });
+        return;
+      }
       const persisted = loadMobileFlowState();
+      console.info("[blink-sdk] guestPreauthMobileRestore.tryStart", {
+        trigger,
+        hasPersistedState: !!persisted,
+        isGuestPreauth: persisted?.isGuestPreauth ?? false,
+        hasGuestSessionToken: !!persisted?.guestSessionToken,
+        hasSessionId: !!persisted?.sessionId,
+        accountId: persisted?.accountId ?? null
+      });
       if (!persisted?.isGuestPreauth || !persisted.guestSessionToken || !persisted.sessionId) {
         return;
       }
@@ -8868,15 +8976,28 @@ function useGuestPreauthMobileRestoreEffect(deps) {
         type: "MOBILE_DEEPLINK_READY",
         deeplinkUri: persisted.deeplinkUri
       });
+      console.info("[blink-sdk] guestPreauthMobileRestore: starting guest account polling", {
+        trigger,
+        sessionId: persisted.sessionId
+      });
       startGuestAccountPolling(persisted.guestSessionToken, persisted.sessionId);
     };
     const onVisibility = () => {
-      if (document.visibilityState === "visible") tryStart();
+      console.info("[blink-sdk] guestPreauthMobileRestore: visibilitychange fired", {
+        visibilityState: document.visibilityState,
+        startedRef: startedRef.current
+      });
+      if (document.visibilityState === "visible") tryStart("visibilitychange");
     };
-    const onPageShow = () => {
-      if (document.visibilityState === "visible") tryStart();
+    const onPageShow = (e) => {
+      console.info("[blink-sdk] guestPreauthMobileRestore: pageshow fired", {
+        persisted: e.persisted,
+        visibilityState: document.visibilityState,
+        startedRef: startedRef.current
+      });
+      if (document.visibilityState === "visible") tryStart("pageshow");
     };
-    tryStart();
+    tryStart("initial");
     document.addEventListener("visibilitychange", onVisibility);
     window.addEventListener("pageshow", onPageShow);
     return () => {
@@ -9144,16 +9265,37 @@ function useGuestPreauthWalletSetupEffect(deps) {
     dispatch
   ]);
 }
+function useGuestAccountAutoPollingEffect(deps) {
+  const {
+    mobileFlow,
+    isGuestFlow,
+    guestSessionToken,
+    isPolling,
+    guestAccount,
+    startPolling
+  } = deps;
+  react.useEffect(() => {
+    if (!mobileFlow || !isGuestFlow || !guestSessionToken) return;
+    if (isPolling || guestAccount) return;
+    startPolling(guestSessionToken);
+  }, [mobileFlow, isGuestFlow, guestSessionToken, isPolling, guestAccount, startPolling]);
+}
 function useGuestAccountPolling(intervalMs = 3e3) {
   const { apiBaseUrl } = useBlinkConfig();
   const [guestAccount, setGuestAccount] = react.useState(null);
   const [isPolling, setIsPolling] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const consecutiveFailuresRef = react.useRef(0);
   const intervalRef = react.useRef(null);
   const guestTokenRef = react.useRef(null);
   const sessionIdRef = react.useRef(null);
   const apiBaseUrlRef = react.useRef(apiBaseUrl);
   apiBaseUrlRef.current = apiBaseUrl;
   const stopPolling = react.useCallback(() => {
+    console.info("[blink-sdk] useGuestAccountPolling.stopPolling called", {
+      hadInterval: !!intervalRef.current,
+      hadToken: !!guestTokenRef.current
+    });
     if (intervalRef.current) {
       clearInterval(intervalRef.current);
       intervalRef.current = null;
@@ -9165,29 +9307,70 @@ function useGuestAccountPolling(intervalMs = 3e3) {
   const poll = react.useCallback(async () => {
     const token = guestTokenRef.current;
     const sessionId = sessionIdRef.current;
-    if (!token || !sessionId) return;
+    if (!token) {
+      console.info("[blink-sdk] useGuestAccountPolling.poll skipped (no token)");
+      return;
+    }
+    console.info("[blink-sdk] useGuestAccountPolling.poll executing", {
+      apiBaseUrl: apiBaseUrlRef.current,
+      tokenPrefix: token.slice(0, 8),
+      sessionId: sessionId ?? "(none \u2014 account-only mode)"
+    });
     try {
       const lookup = await fetchGuestAccount(apiBaseUrlRef.current, token);
       if (!guestTokenRef.current) return;
-      if (lookup == null) return;
+      consecutiveFailuresRef.current = 0;
+      setError(null);
+      if (lookup == null) {
+        console.info("[blink-sdk] useGuestAccountPolling.poll: account not found yet");
+        return;
+      }
+      if (!sessionId) {
+        console.info("[blink-sdk] useGuestAccountPolling.poll: COMPLETE \u2014 account found (no session check)");
+        setGuestAccount(lookup);
+        stopPolling();
+        return;
+      }
+      console.info("[blink-sdk] useGuestAccountPolling.poll: account found, checking session");
       try {
         const session = await fetchAuthorizationSession(apiBaseUrlRef.current, sessionId);
         if (!guestTokenRef.current) return;
-        if (session.status !== "AUTHORIZED") return;
-      } catch {
+        if (session.status !== "AUTHORIZED") {
+          console.info("[blink-sdk] useGuestAccountPolling.poll: session not AUTHORIZED yet", session.status);
+          return;
+        }
+      } catch (sessionErr) {
+        consecutiveFailuresRef.current += 1;
+        console.info("[blink-sdk] useGuestAccountPolling.poll: session fetch failed", sessionErr);
+        if (consecutiveFailuresRef.current >= 3) {
+          setError(sessionErr instanceof Error ? sessionErr.message : "Failed to check authorization status");
+        }
         return;
       }
+      console.info("[blink-sdk] useGuestAccountPolling.poll: COMPLETE \u2014 account + AUTHORIZED");
       setGuestAccount(lookup);
       stopPolling();
-    } catch {
+    } catch (err) {
+      consecutiveFailuresRef.current += 1;
+      console.info("[blink-sdk] useGuestAccountPolling.poll: fetch error, will retry", err);
+      if (consecutiveFailuresRef.current >= 3) {
+        setError(err instanceof Error ? err.message : "Failed to check account status");
+      }
     }
   }, [stopPolling]);
   const startPolling = react.useCallback(
     (guestToken, sessionId) => {
+      console.info("[blink-sdk] useGuestAccountPolling.startPolling called", {
+        tokenPrefix: guestToken.slice(0, 8),
+        sessionId: sessionId ?? "(none \u2014 account-only mode)",
+        intervalMs
+      });
       stopPolling();
       guestTokenRef.current = guestToken;
-      sessionIdRef.current = sessionId;
+      sessionIdRef.current = sessionId ?? null;
       setGuestAccount(null);
+      setError(null);
+      consecutiveFailuresRef.current = 0;
       setIsPolling(true);
       poll();
       intervalRef.current = setInterval(poll, intervalMs);
@@ -9196,11 +9379,22 @@ function useGuestAccountPolling(intervalMs = 3e3) {
   );
   react.useEffect(() => {
     const handleVisibility = () => {
+      console.info("[blink-sdk] useGuestAccountPolling: visibilitychange fired", {
+        visibilityState: document.visibilityState,
+        hasToken: !!guestTokenRef.current,
+        hasSessionId: !!sessionIdRef.current
+      });
       if (document.visibilityState === "visible" && guestTokenRef.current) {
         void poll();
       }
     };
-    const handlePageShow = () => {
+    const handlePageShow = (e) => {
+      console.info("[blink-sdk] useGuestAccountPolling: pageshow fired", {
+        persisted: e.persisted,
+        visibilityState: document.visibilityState,
+        hasToken: !!guestTokenRef.current,
+        hasSessionId: !!sessionIdRef.current
+      });
       if (document.visibilityState === "visible" && guestTokenRef.current) {
         void poll();
       }
@@ -9213,7 +9407,7 @@ function useGuestAccountPolling(intervalMs = 3e3) {
     };
   }, [poll]);
   react.useEffect(() => () => stopPolling(), [stopPolling]);
-  return { guestAccount, isPolling, startPolling, stopPolling };
+  return { guestAccount, error, isPolling, startPolling, stopPolling };
 }
 function BlinkPayment(props) {
   const resetKey = react.useRef(0);
@@ -9296,6 +9490,12 @@ function BlinkPaymentInner({
     transfer.pollingTransferIdRef,
     state.transfer,
     mobileFlowRefs,
+    {
+      mobileFlow: state.mobileFlow,
+      isGuestFlow: state.isGuestFlow,
+      guestTransferId: state.guestTransferId,
+      guestSessionToken: state.guestSessionToken
+    },
     onComplete
   );
   const sourceSelection = useSourceSelectionHandlers(dispatch, authExecutor, {
@@ -9400,10 +9600,50 @@ function BlinkPaymentInner({
     setupAccountIdRef: mobileFlowRefs.setupAccountIdRef,
     startGuestAccountPolling: guestAccountPolling.startPolling
   });
+  useGuestAccountAutoPollingEffect({
+    mobileFlow: state.mobileFlow,
+    isGuestFlow: state.isGuestFlow,
+    guestSessionToken: state.guestSessionToken,
+    isPolling: guestAccountPolling.isPolling,
+    guestAccount: guestAccountPolling.guestAccount,
+    startPolling: guestAccountPolling.startPolling
+  });
+  const guestSessionTokenRef = react.useRef(state.guestSessionToken);
+  guestSessionTokenRef.current = state.guestSessionToken;
+  const guestPreauthSessionIdRef = react.useRef(state.guestPreauthSessionId);
+  guestPreauthSessionIdRef.current = state.guestPreauthSessionId;
+  react.useEffect(() => {
+    const handleVisibility = () => {
+      if (document.visibilityState !== "visible") return;
+      const token = guestSessionTokenRef.current;
+      const sessionId = guestPreauthSessionIdRef.current;
+      if (!token) return;
+      if (guestAccountPolling.isPolling || guestAccountPolling.guestAccount) return;
+      console.info("[blink-sdk] warm-return: restarting guest account polling from React state", {
+        sessionId: sessionId ?? "(none \u2014 account-only mode)"
+      });
+      guestAccountPolling.startPolling(token, sessionId ?? void 0);
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    return () => document.removeEventListener("visibilitychange", handleVisibility);
+  }, [guestAccountPolling.isPolling, guestAccountPolling.guestAccount, guestAccountPolling.startPolling]);
   react.useEffect(() => {
+    console.info("[blink-sdk] guestPreauthCompletion effect", {
+      hasGuestAccount: !!guestAccountPolling.guestAccount,
+      guestAccountId: guestAccountPolling.guestAccount?.accountId ?? null,
+      currentPreauthAccountId: state.guestPreauthAccountId,
+      currentPhase: state.phase.step,
+      mobileFlow: state.mobileFlow,
+      loginRequested: state.loginRequested
+    });
     if (!guestAccountPolling.guestAccount) return;
     const acct = guestAccountPolling.guestAccount;
-    if (acct.accountId !== state.guestPreauthAccountId) {
+    const needsDetect = acct.accountId !== state.guestPreauthAccountId;
+    console.info("[blink-sdk] guestPreauthCompletion: dispatching REQUEST_LOGIN + MOBILE_SETUP_COMPLETE", {
+      accountId: acct.accountId,
+      dispatchingGuestPreauthDetected: needsDetect
+    });
+    if (needsDetect) {
       dispatch({
         type: "GUEST_PREAUTH_DETECTED",
         accountId: acct.accountId,
@@ -9445,7 +9685,8 @@ function BlinkPaymentInner({
     reauthTokenRef: mobileFlowRefs.reauthTokenRef,
     pollingTransferIdRef: transfer.pollingTransferIdRef,
     handleAuthorizedMobileReturn: mobileFlow.handleAuthorizedMobileReturn,
-    onComplete
+    onComplete,
+    startGuestAccountPolling: guestAccountPolling.startPolling
   });
   useDataLoadEffect({
     state,
@@ -9592,6 +9833,7 @@ function BlinkPaymentInner({
       remote: {
         pollingTransfer: polling.transfer,
         pollingError: polling.error,
+        guestAccountPollingError: guestAccountPolling.error,
         authExecutorError: authExecutor.error,
         transferSigningSigning: transferSigning.signing,
         transferSigningError: transferSigning.error,