@n1xyz/wallet-widget 0.0.34 → 0.0.35-alpha.1

package/dist/src/turnkey/TurnkeyProvider.js

@@ -0,0 +1,695 @@
+"use client";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_SESSION_EXPIRATION_IN_SECONDS, StamperType, TurnkeyClient } from "@turnkey/core";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { TURNKEY_CONFIG } from "../config/turnkey";
+import { useN1WalletContext } from "../hooks";
+import { useNetwork, useNetworkActions } from "../providers/N1WalletProvider/NetworkProvider";
+import { logger } from "../utils/logger";
+import { EVENTS, createTurnkeyEvent } from "../utils/events";
+import { createTurnkeyError } from "../utils/errors";
+import { createTurnkeySolanaWallet } from "./createTurnkeyWallet";
+import { buildWalletProvider } from "./createWalletProvider";
+import { TurnkeyAuthState, } from "./types";
+import { normalizeAddress as normalizeAddressService, isUserRejectedError, isSessionForDifferentUser, hasStoredSession, getStoredSession, storeSession, clearSession, updateSessionSolanaAccount, getCachedSolanaAccount, TURNKEY_WALLET_NAME as SERVICE_TURNKEY_WALLET_NAME, SOLANA_ADDRESS_FORMAT as SERVICE_SOLANA_ADDRESS_FORMAT, } from "../services/bootstrap";
+import { StorageService } from "../services/storage";
+import { useWalletStore, getWalletActions } from "../store";
+// Re-export constants for backwards compatibility
+export var TURNKEY_WALLET_NAME = SERVICE_TURNKEY_WALLET_NAME;
+var SOLANA_ADDRESS_FORMAT = SERVICE_SOLANA_ADDRESS_FORMAT;
+// Use service for address normalization
+var normalizeAddress = normalizeAddressService;
+var TurnkeyContext = createContext(null);
+/**
+ * Provider component that manages Turnkey authentication and wallet operations.
+ *
+ * Simplified Flow:
+ * 1. Monitor EVM address.
+ * 2. If EVM address changes or is missing -> Reset state.
+ * 3. If EVM address is present -> Run `prepareTurnkeyWallet`.
+ *    a. Check if we need to logout (previous session != current address).
+ *    b. Hydrate/Login.
+ *    c. Ensure Solana account.
+ */
+export function TurnkeyProvider(_a) {
+    var _this = this;
+    var children = _a.children;
+    // -- State --
+    var turnkeyConfig = TURNKEY_CONFIG !== null && TURNKEY_CONFIG !== void 0 ? TURNKEY_CONFIG : undefined;
+    var _b = useState(TurnkeyAuthState.Unauthenticated), turnkeyAuthState = _b[0], setTurnkeyAuthState = _b[1];
+    var _c = useState([]), turnkeyWallets = _c[0], setTurnkeyWallets = _c[1];
+    var _d = useState(null), turnkeySession = _d[0], setTurnkeySession = _d[1];
+    var _e = useState(false), isHydratingSession = _e[0], setIsHydratingSession = _e[1];
+    var _f = useState(null), turnkeyAddress = _f[0], setTurnkeyAddress = _f[1];
+    // -- Bootstrap slice state (single source of truth for status/error) --
+    var turnkeyStatus = useWalletStore(function (state) { return state.bootstrap.turnkeyStatus; });
+    var turnkeyError = useWalletStore(function (state) { return state.bootstrap.turnkeyError; });
+    var bootstrapActions = getWalletActions().bootstrap;
+    // Helper to update turnkey status in the store
+    var setTurnkeyStatus = useCallback(function (status) {
+        bootstrapActions.setTurnkeyStatus(status);
+    }, [bootstrapActions]);
+    var setTurnkeyError = useCallback(function (error) {
+        bootstrapActions.setTurnkeyError(error);
+    }, [bootstrapActions]);
+    // Initialize status based on config
+    useEffect(function () {
+        if (!turnkeyConfig) {
+            setTurnkeyStatus('ready');
+        }
+    }, [turnkeyConfig, setTurnkeyStatus]);
+    // -- Refs --
+    var turnkeyClientRef = useRef(null);
+    var turnkeyClientInitPromiseRef = useRef(null);
+    var bootstrapInFlightRef = useRef(null);
+    var authenticatedWalletAddressRef = useRef(null);
+    var solanaAccountRef = useRef(null);
+    var lastTurnkeyWalletsRef = useRef([]);
+    var lastTurnkeyRefreshAtRef = useRef(0);
+    // -- Context --
+    var walletNetwork = useN1WalletContext().walletNetwork;
+    var _g = useNetwork(), evmAddress = _g.evmAddress, evmWallet = _g.evmWallet;
+    var _h = useNetworkActions(), setSolanaWallet = _h.setSolanaWallet, setSolanaAddress = _h.setSolanaAddress;
+    // -- Helpers --
+    var resetTurnkeyState = useCallback(function (options) {
+        logger.debug("[Turnkey] Resetting state");
+        bootstrapActions.setTurnkeyStatus(turnkeyConfig ? "idle" : "ready");
+        bootstrapActions.setTurnkeyError(null);
+        setTurnkeyAddress(null);
+        setTurnkeySession(null);
+        setTurnkeyAuthState(TurnkeyAuthState.Unauthenticated);
+        setTurnkeyWallets([]);
+        solanaAccountRef.current = null;
+        authenticatedWalletAddressRef.current = null;
+        if (!(options === null || options === void 0 ? void 0 : options.keepInFlight)) {
+            bootstrapInFlightRef.current = null;
+        }
+        // Clear N1 Context state
+        setSolanaWallet(null);
+        setSolanaAddress("");
+    }, [setSolanaAddress, setSolanaWallet, turnkeyConfig, bootstrapActions]);
+    var getTurnkeyClient = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            if (!turnkeyConfig)
+                throw new Error("Turnkey config missing");
+            if (turnkeyClientRef.current)
+                return [2 /*return*/, turnkeyClientRef.current];
+            if (!turnkeyClientInitPromiseRef.current) {
+                turnkeyClientInitPromiseRef.current = (function () { return __awaiter(_this, void 0, void 0, function () {
+                    var client;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                client = new TurnkeyClient({
+                                    organizationId: turnkeyConfig.organizationId,
+                                    authProxyConfigId: turnkeyConfig.authProxyConfigId,
+                                    authProxyUrl: turnkeyConfig.authProxyUrl,
+                                    apiBaseUrl: turnkeyConfig.apiBaseUrl,
+                                    defaultStamperType: undefined, // We set this explicitly when needed
+                                    walletConfig: {
+                                        features: { auth: true, connecting: true },
+                                        chains: { ethereum: { native: true }, solana: { native: true } },
+                                    },
+                                });
+                                return [4 /*yield*/, client.init()];
+                            case 1:
+                                _a.sent();
+                                turnkeyClientRef.current = client;
+                                return [2 /*return*/, client];
+                        }
+                    });
+                }); })();
+            }
+            return [2 /*return*/, turnkeyClientInitPromiseRef.current];
+        });
+    }); }, [turnkeyConfig]);
+    var refreshTurnkeyWallets = useCallback(function (options) { return __awaiter(_this, void 0, void 0, function () {
+        var now, client, wallets, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    now = Date.now();
+                    // Cache for 5 seconds
+                    if (!(options === null || options === void 0 ? void 0 : options.force) && now - lastTurnkeyRefreshAtRef.current < 5000 && lastTurnkeyWalletsRef.current.length > 0) {
+                        return [2 /*return*/, lastTurnkeyWalletsRef.current];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, getTurnkeyClient()];
+                case 2:
+                    client = _a.sent();
+                    return [4 /*yield*/, client.fetchWallets()];
+                case 3:
+                    wallets = _a.sent();
+                    if (Array.isArray(wallets)) {
+                        setTurnkeyWallets(wallets);
+                        lastTurnkeyWalletsRef.current = wallets;
+                        lastTurnkeyRefreshAtRef.current = now;
+                        return [2 /*return*/, wallets];
+                    }
+                    return [2 /*return*/, []];
+                case 4:
+                    error_1 = _a.sent();
+                    logger.logError(createTurnkeyError('WALLET_FETCH_FAILED', 'Failed to fetch Turnkey wallets', {
+                        cause: error_1 instanceof Error ? error_1 : undefined,
+                    }));
+                    return [2 /*return*/, []];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [getTurnkeyClient]);
+    var signTurnkeyMessage = useCallback(function (params) { return __awaiter(_this, void 0, void 0, function () {
+        var client;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getTurnkeyClient()];
+                case 1:
+                    client = _a.sent();
+                    return [4 /*yield*/, client.signMessage(params)];
+                case 2: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, [getTurnkeyClient]);
+    var signTurnkeyTransaction = useCallback(function (params) { return __awaiter(_this, void 0, void 0, function () {
+        var client;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getTurnkeyClient()];
+                case 1:
+                    client = _a.sent();
+                    return [4 /*yield*/, client.signTransaction(params)];
+                case 2: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, [getTurnkeyClient]);
+    // -- Main Logic --
+    /**
+     * 1. Perform Logout / Cleanup if needed.
+     * Returns true if we are clean and ready to proceed with `targetAddress`.
+     */
+    var ensureCleanSessionForAddress = function (targetAddress) { return __awaiter(_this, void 0, void 0, function () {
+        var isDifferentUser, client, e_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    isDifferentUser = isSessionForDifferentUser(targetAddress);
+                    if (!isDifferentUser) return [3 /*break*/, 6];
+                    logger.debug("[Turnkey] User switch detected, cleaning up", { target: targetAddress });
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, getTurnkeyClient()];
+                case 2:
+                    client = _b.sent();
+                    return [4 /*yield*/, ((_a = client.logout) === null || _a === void 0 ? void 0 : _a.call(client))];
+                case 3:
+                    _b.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    e_1 = _b.sent();
+                    return [3 /*break*/, 5];
+                case 5:
+                    // Pass no address to unconditionally clear the OLD user's session
+                    // (passing targetAddress would fail because the stored session belongs to the previous user)
+                    clearSession();
+                    resetTurnkeyState({ keepInFlight: true });
+                    StorageService.writeTurnkeyClientAddress(targetAddress);
+                    return [3 /*break*/, 7];
+                case 6:
+                    if (!StorageService.readTurnkeyClientAddress()) {
+                        StorageService.writeTurnkeyClientAddress(targetAddress);
+                    }
+                    _b.label = 7;
+                case 7: return [2 /*return*/];
+            }
+        });
+    }); };
+    /**
+     * 2. Hydrate Session from Storage
+     */
+    var hydrateSession = function (targetAddress) { return __awaiter(_this, void 0, void 0, function () {
+        var stored, client, session, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    stored = getStoredSession(targetAddress);
+                    if (!(stored === null || stored === void 0 ? void 0 : stored.sessionKey))
+                        return [2 /*return*/, null];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, getTurnkeyClient()];
+                case 2:
+                    client = _a.sent();
+                    // Verify if session is still valid? Turnkey client usually handles expiration.
+                    return [4 /*yield*/, client.setActiveSession({ sessionKey: stored.sessionKey })];
+                case 3:
+                    // Verify if session is still valid? Turnkey client usually handles expiration.
+                    _a.sent();
+                    session = __assign({ sessionKey: stored.sessionKey }, stored.session);
+                    // We assume stored session is valid if we have it
+                    setTurnkeySession(session);
+                    setTurnkeyAuthState(TurnkeyAuthState.Authenticated);
+                    authenticatedWalletAddressRef.current = targetAddress;
+                    return [2 /*return*/, session];
+                case 4:
+                    error_2 = _a.sent();
+                    logger.logError(createTurnkeyError('SESSION_INVALID', 'Failed to hydrate Turnkey session', {
+                        cause: error_2 instanceof Error ? error_2 : undefined,
+                        context: { targetAddress: targetAddress },
+                    }));
+                    clearSession(targetAddress); // Clear invalid session
+                    return [2 /*return*/, null];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    /**
+     * 3. Login (if not hydrated)
+     */
+    var performLogin = function (wallet, targetAddress) { return __awaiter(_this, void 0, void 0, function () {
+        var client, previousStamper, walletProvider, expirationSeconds, sessionKey, sessionResponse, session, error_3;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    setTurnkeyAuthState(TurnkeyAuthState.Authenticating);
+                    logger.event(createTurnkeyEvent(EVENTS.TURNKEY.AUTH_START, {
+                        evmAddress: targetAddress,
+                    }));
+                    return [4 /*yield*/, getTurnkeyClient()];
+                case 1:
+                    client = _b.sent();
+                    previousStamper = client.httpClient.defaultStamperType;
+                    client.httpClient.defaultStamperType = StamperType.Wallet;
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 7, 8, 9]);
+                    logger.debug("[Turnkey] [performLogin] Building wallet provider", { targetAddress: targetAddress });
+                    return [4 /*yield*/, buildWalletProvider(wallet)];
+                case 3:
+                    walletProvider = _b.sent();
+                    expirationSeconds = (_a = turnkeyConfig === null || turnkeyConfig === void 0 ? void 0 : turnkeyConfig.sessionExpirationSeconds) !== null && _a !== void 0 ? _a : DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+                    logger.debug("[Turnkey] [performLogin] Calling loginOrSignupWithWallet", { expirationSeconds: expirationSeconds });
+                    return [4 /*yield*/, client.loginOrSignupWithWallet({
+                            walletProvider: walletProvider,
+                            expirationSeconds: expirationSeconds,
+                        })];
+                case 4:
+                    _b.sent();
+                    logger.debug("[Turnkey] [performLogin] loginOrSignupWithWallet completed successfully");
+                    return [4 /*yield*/, client.getActiveSessionKey()];
+                case 5:
+                    sessionKey = _b.sent();
+                    if (!sessionKey) {
+                        logger.logError(createTurnkeyError('SESSION_INVALID', 'No session key after login'));
+                        throw new Error("No session key after login");
+                    }
+                    logger.debug("[Turnkey] [performLogin] Got session key", { sessionKey: sessionKey.substring(0, 10) + "..." });
+                    return [4 /*yield*/, client.getSession({ sessionKey: sessionKey })];
+                case 6:
+                    sessionResponse = _b.sent();
+                    session = __assign(__assign({}, sessionResponse), { sessionKey: sessionKey });
+                    storeSession(targetAddress, sessionKey, {
+                        evmAddress: targetAddress,
+                        session: session,
+                    });
+                    setTurnkeySession(session);
+                    setTurnkeyAuthState(TurnkeyAuthState.Authenticated);
+                    authenticatedWalletAddressRef.current = targetAddress;
+                    logger.event(createTurnkeyEvent(EVENTS.TURNKEY.AUTH_SUCCESS, {
+                        evmAddress: targetAddress,
+                    }));
+                    return [2 /*return*/, session];
+                case 7:
+                    error_3 = _b.sent();
+                    // Log the error with context about where it occurred
+                    logger.event(createTurnkeyEvent(EVENTS.TURNKEY.AUTH_FAILED, {
+                        evmAddress: targetAddress,
+                        errorCode: error_3 === null || error_3 === void 0 ? void 0 : error_3.code,
+                    }));
+                    logger.logError(createTurnkeyError('AUTH_FAILED', error_3 instanceof Error ? error_3.message : 'Login failed', {
+                        cause: error_3 instanceof Error ? error_3 : undefined,
+                        context: {
+                            errorCode: error_3 === null || error_3 === void 0 ? void 0 : error_3.code,
+                            errorName: error_3 === null || error_3 === void 0 ? void 0 : error_3.name,
+                            targetAddress: targetAddress,
+                        },
+                    }));
+                    throw error_3; // Re-throw to be handled by bootstrap error handler
+                case 8:
+                    client.httpClient.defaultStamperType = previousStamper;
+                    return [7 /*endfinally*/];
+                case 9: return [2 /*return*/];
+            }
+        });
+    }); };
+    /**
+     * 4. Ensure Solana Account
+     */
+    var ensureSolanaWallet = function (targetAddress) { return __awaiter(_this, void 0, void 0, function () {
+        var cachedSolana, syntheticAccount, syntheticWallet, wallet, wallets, existing, client, previousStamper, walletId_1, error_4, account, turnkeyWallet;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    // Use cached if available
+                    if (solanaAccountRef.current)
+                        return [2 /*return*/, solanaAccountRef.current];
+                    cachedSolana = getCachedSolanaAccount(targetAddress);
+                    if ((_a = cachedSolana === null || cachedSolana === void 0 ? void 0 : cachedSolana.account) === null || _a === void 0 ? void 0 : _a.address) {
+                        syntheticAccount = __assign(__assign({}, cachedSolana.account), { addressFormat: SOLANA_ADDRESS_FORMAT, walletId: cachedSolana.walletId });
+                        syntheticWallet = {
+                            walletId: cachedSolana.walletId,
+                            walletName: TURNKEY_WALLET_NAME,
+                            accounts: [syntheticAccount],
+                        };
+                        wallet = createTurnkeySolanaWallet({
+                            walletAccount: syntheticAccount,
+                            signMessage: signTurnkeyMessage,
+                            signTransaction: signTurnkeyTransaction,
+                        });
+                        solanaAccountRef.current = { wallet: syntheticWallet, account: syntheticAccount };
+                        setSolanaWallet(wallet);
+                        setSolanaAddress(syntheticAccount.address);
+                        setTurnkeyAddress(syntheticAccount.address);
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, refreshTurnkeyWallets({ force: true })];
+                case 1:
+                    wallets = _c.sent();
+                    existing = wallets.find(function (w) {
+                        var _a;
+                        return w.walletName === TURNKEY_WALLET_NAME &&
+                            ((_a = w.accounts) === null || _a === void 0 ? void 0 : _a.some(function (a) { return a.addressFormat === SOLANA_ADDRESS_FORMAT; }));
+                    });
+                    if (!!existing) return [3 /*break*/, 7];
+                    return [4 /*yield*/, getTurnkeyClient()];
+                case 2:
+                    client = _c.sent();
+                    previousStamper = client.httpClient.defaultStamperType;
+                    _c.label = 3;
+                case 3:
+                    _c.trys.push([3, 6, , 7]);
+                    return [4 /*yield*/, client.createWallet({
+                            walletName: TURNKEY_WALLET_NAME,
+                            accounts: [SOLANA_ADDRESS_FORMAT],
+                        })];
+                case 4:
+                    walletId_1 = _c.sent();
+                    logger.event(createTurnkeyEvent(EVENTS.TURNKEY.WALLET_CREATE, {
+                        walletId: walletId_1,
+                        evmAddress: targetAddress,
+                    }));
+                    return [4 /*yield*/, refreshTurnkeyWallets({ force: true })];
+                case 5:
+                    wallets = _c.sent();
+                    existing = wallets.find(function (w) { return w.walletId === walletId_1; });
+                    return [3 /*break*/, 7];
+                case 6:
+                    error_4 = _c.sent();
+                    logger.logError(createTurnkeyError('WALLET_CREATE_FAILED', 'Failed to create Turnkey wallet', {
+                        cause: error_4 instanceof Error ? error_4 : undefined,
+                        context: { targetAddress: targetAddress },
+                    }));
+                    throw error_4;
+                case 7:
+                    if (!existing)
+                        throw new Error("Failed to find or create Solana wallet");
+                    account = (_b = existing.accounts) === null || _b === void 0 ? void 0 : _b.find(function (a) { return a.addressFormat === SOLANA_ADDRESS_FORMAT; });
+                    if (!account)
+                        throw new Error("Wallet created but missing Solana account");
+                    // Update Storage using service helper
+                    updateSessionSolanaAccount(targetAddress, {
+                        walletId: existing.walletId,
+                        account: { address: account.address, addressFormat: account.addressFormat }
+                    });
+                    turnkeyWallet = createTurnkeySolanaWallet({
+                        walletAccount: account,
+                        signMessage: signTurnkeyMessage,
+                        signTransaction: signTurnkeyTransaction,
+                    });
+                    solanaAccountRef.current = { wallet: existing, account: account };
+                    setSolanaWallet(turnkeyWallet);
+                    setSolanaAddress(account.address);
+                    setTurnkeyAddress(account.address);
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    // -- Bootstrap Effect --
+    useEffect(function () {
+        var bootstrap = function () { return __awaiter(_this, void 0, void 0, function () {
+            var targetAddress, shouldReset;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        targetAddress = normalizeAddress(evmAddress);
+                        // DEBUG: Log all inputs to bootstrap effect
+                        logger.debug("[Turnkey] Bootstrap effect running", {
+                            hasConfig: !!turnkeyConfig,
+                            walletNetwork: walletNetwork,
+                            hasEvmWallet: !!evmWallet,
+                            evmWalletAddress: evmWallet === null || evmWallet === void 0 ? void 0 : evmWallet.address,
+                            targetAddress: targetAddress,
+                            turnkeyStatus: turnkeyStatus,
+                            hasBootstrapInFlight: !!bootstrapInFlightRef.current,
+                            authenticatedAddress: authenticatedWalletAddressRef.current,
+                            hasSolanaAccount: !!solanaAccountRef.current,
+                        });
+                        // 1. Pre-flight checks
+                        if (!turnkeyConfig || walletNetwork !== 'evm' || !evmWallet || !targetAddress) {
+                            shouldReset = !bootstrapInFlightRef.current &&
+                                ((turnkeyStatus !== 'idle' && turnkeyStatus !== 'ready' && turnkeyStatus !== 'error') ||
+                                    (turnkeyStatus === 'ready' && !evmWallet));
+                            logger.debug("[Turnkey] Pre-flight failed", {
+                                reason: !turnkeyConfig ? 'no config' : walletNetwork !== 'evm' ? "walletNetwork=".concat(walletNetwork) : !evmWallet ? 'no evmWallet' : 'no targetAddress',
+                                shouldReset: shouldReset,
+                                turnkeyStatus: turnkeyStatus,
+                            });
+                            if (shouldReset) {
+                                resetTurnkeyState();
+                            }
+                            return [2 /*return*/];
+                        }
+                        // If we are already ready and address hasn't changed, do nothing
+                        if (turnkeyStatus === 'ready' && authenticatedWalletAddressRef.current === targetAddress && solanaAccountRef.current) {
+                            logger.debug("[Turnkey] Already ready, skipping");
+                            return [2 /*return*/];
+                        }
+                        // Prevent concurrent runs
+                        if (bootstrapInFlightRef.current) {
+                            logger.debug("[Turnkey] Bootstrap in flight, skipping");
+                            return [2 /*return*/];
+                        }
+                        // Only start bootstrap if status is 'idle' (initial or after reset)
+                        // Skip if status is 'authenticating', 'creating', or 'error' - these are handled elsewhere
+                        if (turnkeyStatus !== 'idle') {
+                            logger.debug("[Turnkey] Status not idle, skipping", { turnkeyStatus: turnkeyStatus });
+                            return [2 /*return*/];
+                        }
+                        logger.debug("[Turnkey] Starting bootstrap - setting authenticating");
+                        setTurnkeyStatus("authenticating");
+                        setTurnkeyError(null);
+                        bootstrapInFlightRef.current = (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var session, error_5, errorMessage, isUserRejection;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 7, 8, 9]);
+                                        logger.debug("[Turnkey] Starting bootstrap", { targetAddress: targetAddress });
+                                        // 2. Ensure Clean Session
+                                        return [4 /*yield*/, ensureCleanSessionForAddress(targetAddress)];
+                                    case 1:
+                                        // 2. Ensure Clean Session
+                                        _a.sent();
+                                        session = null;
+                                        if (!hasStoredSession(targetAddress)) return [3 /*break*/, 3];
+                                        setIsHydratingSession(true);
+                                        return [4 /*yield*/, hydrateSession(targetAddress)];
+                                    case 2:
+                                        session = _a.sent();
+                                        setIsHydratingSession(false);
+                                        _a.label = 3;
+                                    case 3:
+                                        if (!!session) return [3 /*break*/, 5];
+                                        logger.debug("[Turnkey] No session, logging in...");
+                                        return [4 /*yield*/, performLogin(evmWallet, targetAddress)];
+                                    case 4:
+                                        session = _a.sent();
+                                        _a.label = 5;
+                                    case 5:
+                                        if (!session)
+                                            throw new Error("Failed to establish session");
+                                        // 4. Provision Solana Wallet
+                                        setTurnkeyStatus("creating");
+                                        return [4 /*yield*/, ensureSolanaWallet(targetAddress)];
+                                    case 6:
+                                        _a.sent();
+                                        setTurnkeyStatus("ready");
+                                        logger.debug("[Turnkey] Bootstrap complete");
+                                        return [3 /*break*/, 9];
+                                    case 7:
+                                        error_5 = _a.sent();
+                                        errorMessage = error_5 instanceof Error ? error_5.message : 'Turnkey bootstrap failed';
+                                        isUserRejection = isUserRejectedError(error_5);
+                                        logger.logError(createTurnkeyError('BOOTSTRAP_FAILED', errorMessage, {
+                                            cause: error_5 instanceof Error ? error_5 : undefined,
+                                            context: {
+                                                targetAddress: targetAddress,
+                                                errorCode: error_5 === null || error_5 === void 0 ? void 0 : error_5.code,
+                                                errorName: error_5 === null || error_5 === void 0 ? void 0 : error_5.name,
+                                                isUserRejection: isUserRejection,
+                                            },
+                                        }));
+                                        // Set error state so UI can show retry/disconnect options
+                                        setTurnkeyStatus('error');
+                                        setTurnkeyError(isUserRejection
+                                            ? 'Signature request was cancelled. Please try again.'
+                                            : errorMessage);
+                                        return [3 /*break*/, 9];
+                                    case 8:
+                                        bootstrapInFlightRef.current = null;
+                                        setIsHydratingSession(false);
+                                        return [7 /*endfinally*/];
+                                    case 9: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                        return [4 /*yield*/, bootstrapInFlightRef.current];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        bootstrap();
+    }, [evmAddress, walletNetwork, evmWallet, turnkeyConfig, turnkeyStatus]); // Added turnkeyStatus to trigger bootstrap on retry
+    // -- Exposed API --
+    var waitForSessionHydration = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!bootstrapInFlightRef.current) return [3 /*break*/, 2];
+                    return [4 /*yield*/, bootstrapInFlightRef.current];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
+            }
+        });
+    }); }, []);
+    var createTurnkeyWallet = useCallback(function (params) { return __awaiter(_this, void 0, void 0, function () {
+        var client;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getTurnkeyClient()];
+                case 1:
+                    client = _a.sent();
+                    return [4 /*yield*/, client.createWallet(params)];
+                case 2: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, [getTurnkeyClient]);
+    var retryTurnkeyBootstrap = useCallback(function () {
+        resetTurnkeyState(); // This will trigger the effect again as dependencies change or we reset
+    }, [resetTurnkeyState]);
+    var turnkeyContextValue = useMemo(function () { return ({
+        turnkeyAuthState: turnkeyAuthState,
+        turnkeySession: turnkeySession,
+        turnkeyWallets: turnkeyWallets,
+        isHydratingSession: isHydratingSession,
+        turnkeyStatus: turnkeyStatus,
+        turnkeyError: turnkeyError,
+        turnkeyAddress: turnkeyAddress,
+        createTurnkeyWallet: createTurnkeyWallet,
+        refreshTurnkeyWallets: refreshTurnkeyWallets,
+        signTurnkeyMessage: signTurnkeyMessage,
+        waitForSessionHydration: waitForSessionHydration,
+        loginWithTurnkeyWallet: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/];
+        }); }); },
+        prepareTurnkeyWallet: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/];
+        }); }); },
+        retryTurnkeyBootstrap: retryTurnkeyBootstrap,
+    }); }, [
+        turnkeyAuthState,
+        turnkeySession,
+        turnkeyWallets,
+        isHydratingSession,
+        turnkeyStatus,
+        turnkeyError,
+        turnkeyAddress,
+        createTurnkeyWallet,
+        refreshTurnkeyWallets,
+        signTurnkeyMessage,
+        waitForSessionHydration,
+        retryTurnkeyBootstrap,
+    ]);
+    if (!turnkeyConfig)
+        return _jsx(_Fragment, { children: children });
+    return (_jsx(TurnkeyContext.Provider, { value: turnkeyContextValue, children: children }));
+}
+export var useTurnkey = function () {
+    var context = useContext(TurnkeyContext);
+    if (!context) {
+        throw new Error("useTurnkey must be used within a TurnkeyProvider");
+    }
+    return context;
+};
+export var useTurnkeyUnsafe = function () {
+    return useContext(TurnkeyContext);
+};
+//# sourceMappingURL=TurnkeyProvider.js.map