shogun-core 3.2.2 → 3.3.0

package/dist/ship/interfaces/ISHIP_00.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * SHIP-00: Decentralized Identity & Authentication Interface
+ *
+ * @title ISHIP_00 - Identity Foundation
+ * @notice Base interface for decentralized identity in Shogun ecosystem
+ *
+ * ## Abstract
+ *
+ * This standard defines the foundational interface for identity that enables:
+ * - Username/password authentication with deterministic key generation
+ * - SEA key pair management (export, import, backup)
+ * - Public key publication and discovery on GunDB
+ * - User registry and lookup system
+ * - Blockchain address derivation (Ethereum, Bitcoin, etc.)
+ *
+ * ## Specification
+ *
+ * Based on:
+ * - GunDB for P2P identity storage
+ * - SEA (Security, Encryption, Authorization) for key management
+ * - Shogun Core DataBase API for authentication
+ * - BIP32-like derivation for blockchain addresses
+ *
+ * ## Usage
+ *
+ * SHIP-00 serves as the foundation for all other SHIPs:
+ * - SHIP-01 (Messaging) depends on SHIP-00 for identity
+ * - SHIP-02 (Address Derivation) extends SHIP-00
+ * - SHIP-03 (Multi-Modal Auth) extends SHIP-00
+ * - SHIP-04 (File Storage) uses SHIP-00 for ACL
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// ============================================================================
+// IMPLEMENTATION EXAMPLE
+// ============================================================================
+/**
+ * Example of how to implement ISHIP_00
+ *
+ * ```typescript
+ * import { ShogunCore } from 'shogun-core';
+ * import { ISHIP_00, SEAPair, AuthResult, SignupResult } from './interfaces/ISHIP_00';
+ *
+ * class IdentityManager implements ISHIP_00 {
+ *     private shogun: ShogunCore;
+ *
+ *     constructor(config: IdentityConfig) {
+ *         this.shogun = new ShogunCore({
+ *             gunOptions: {
+ *                 peers: config.peers,
+ *                 radisk: config.radisk,
+ *                 localStorage: config.localStorage
+ *             },
+ *             scope: config.scope
+ *         });
+ *     }
+ *
+ *     async signup(username: string, password: string): Promise<SignupResult> {
+ *         // Use Shogun Core signUp method
+ *         const result = await this.shogun.signUp(username, password);
+ *
+ *         if (result.success) {
+ *             // Publish public key
+ *             await this.publishPublicKey();
+ *
+ *             // Derive Ethereum address
+ *             const derivedAddress = await this.deriveEthereumAddress(result.userPub);
+ *
+ *             return {
+ *                 success: true,
+ *                 userPub: result.userPub,
+ *                 username: username,
+ *                 derivedAddress: derivedAddress
+ *             };
+ *         }
+ *
+ *         return {
+ *             success: false,
+ *             error: result.error || 'Signup failed'
+ *         };
+ *     }
+ *
+ *     async login(username: string, password: string): Promise<AuthResult> {
+ *         // Use Shogun Core login method
+ *         const result = await this.shogun.login(username, password);
+ *
+ *         if (result.success) {
+ *             const derivedAddress = await this.deriveEthereumAddress(result.userPub);
+ *
+ *             return {
+ *                 success: true,
+ *                 userPub: result.userPub,
+ *                 username: username,
+ *                 derivedAddress: derivedAddress
+ *             };
+ *         }
+ *
+ *         return {
+ *             success: false,
+ *             error: result.error || 'Login failed'
+ *         };
+ *     }
+ *
+ *     exportKeyPair(): SEAPair | null {
+ *         if (!this.isLoggedIn()) return null;
+ *
+ *         const seaPair = (this.shogun.db.gun.user() as any)?._?.sea;
+ *         if (!seaPair) return null;
+ *
+ *         return {
+ *             pub: seaPair.pub,
+ *             priv: seaPair.priv,
+ *             epub: seaPair.epub,
+ *             epriv: seaPair.epriv
+ *         };
+ *     }
+ *
+ *     async getUserByAlias(username: string): Promise<UserData | null> {
+ *         // Use Shogun Core getUserByAlias method
+ *         return await this.shogun.db.getUserByAlias(username);
+ *     }
+ *
+ *     async deriveEthereumAddress(publicKey?: string): Promise<string> {
+ *         // Use shogun-derive package
+ *         const derived = await derive(seaPair.priv, null, {
+ *             includeSecp256k1Ethereum: true
+ *         });
+ *
+ *         return derived.secp256k1Ethereum.address;
+ *     }
+ *
+ *     // ... implement other methods
+ * }
+ * ```
+ */

package/dist/ship/interfaces/ISHIP_01.js

@@ -4,19 +4,25 @@
  *
  * @title ISHIP_01 - Decentralized Encrypted Messaging
  * @notice Interface for decentralized encrypted messaging on GunDB
+ * @dev This interface depends on ISHIP_00 for identity and authentication
  *
  * ## Abstract
  *
  * This standard defines an interface for decentralized messaging that allows:
- * - Username/password authentication
- * - Public key publication on GunDB
  * - End-to-end encrypted message sending (ECDH)
  * - Real-time message reception
  * - Decentralized message history
  *
+ * ## Dependencies
+ *
+ * - ISHIP_00: Identity and authentication layer
+ * - GunDB: P2P storage
+ * - SEA: Cryptography (ECDH + AES-GCM)
+ *
  * ## Specification
  *
  * Based on:
+ * - SHIP-00 for identity management
  * - GunDB for P2P storage
  * - SEA (Security, Encryption, Authorization) for cryptography
  * - ECDH (Elliptic Curve Diffie-Hellman) for key agreement
@@ -26,46 +32,97 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // IMPLEMENTATION EXAMPLE
 // ============================================================================
 /**
- * Example of how to implement ISHIP_01
+ * Example of how to implement ISHIP_01 with ISHIP_00 dependency
  *
  * ```typescript
- * class SecureMessagingApp implements ISHIP_01 {
- *     private shogun: ShogunCore;
+ * import { ISHIP_00 } from './ISHIP_00';
+ * import { ISHIP_01, DecryptedMessage, SendMessageResult } from './ISHIP_01';
  *
- *     constructor(config: MessagingConfig) {
- *         this.shogun = new ShogunCore(config);
+ * class SecureMessagingApp implements ISHIP_01 {
+ *     constructor(private identity: ISHIP_00) {
+ *         // Verify identity is authenticated
+ *         if (!identity.isLoggedIn()) {
+ *             throw new Error('User must be authenticated');
+ *         }
  *     }
  *
- *     async signup(username: string, password: string): Promise<SignupResult> {
- *         const result = await this.shogun.signUp(username, password);
- *         return {
- *             success: result.success,
- *             userPub: result.pub,
- *             derivedAddress: this.pubKeyToAddress(result.pub || "")
- *         };
+ *     getIdentity(): ISHIP_00 {
+ *         return this.identity;
  *     }
  *
  *     async sendMessage(recipientUsername: string, message: string): Promise<SendMessageResult> {
- *         // 1. Get recipient's epub
- *         const recipientKey = await this.getRecipientPublicKey(recipientUsername);
+ *         // 1. Get recipient's public key from identity provider
+ *         const recipientKey = await this.identity.getPublicKey(recipientUsername);
+ *         if (!recipientKey) {
+ *             return { success: false, error: 'Recipient not found' };
+ *         }
  *
- *         // 2. Encrypt with ECDH
- *         const encrypted = await this.shogun.db.crypto.encFor(
+ *         // 2. Get sender's key pair from identity provider
+ *         const senderPair = this.identity.getKeyPair();
+ *         if (!senderPair) {
+ *             return { success: false, error: 'Not authenticated' };
+ *         }
+ *
+ *         // 3. Encrypt with ECDH
+ *         const encrypted = await crypto.encFor(
  *             message,
- *             this.shogun.db.user.is, // sender
- *             { epub: recipientKey.epub } // receiver
+ *             senderPair,
+ *             { epub: recipientKey.epub }
  *         );
  *
- *         // 3. Save to GunDB
- *         await this.shogun.db.user.get('messages/...').put({
+ *         // 4. Save to GunDB
+ *         const messageId = generateId();
+ *         await gun.get('messages').get(messageId).put({
  *             content: encrypted,
- *             from: this.shogun.db.user.is.pub,
+ *             from: senderPair.pub,
  *             to: recipientUsername,
  *             timestamp: Date.now().toString()
  *         });
  *
- *         return { success: true, messageId: '...' };
+ *         return { success: true, messageId };
+ *     }
+ *
+ *     async listenForMessages(onMessage: (message: DecryptedMessage) => void): Promise<void> {
+ *         const currentUser = this.identity.getCurrentUser();
+ *         if (!currentUser) {
+ *             throw new Error('Not authenticated');
+ *         }
+ *
+ *         gun.get('messages').map().on(async (data, key) => {
+ *             if (data && data.to === currentUser.alias) {
+ *                 // Decrypt message
+ *                 const senderKey = await this.identity.getPublicKey(data.from);
+ *                 const receiverPair = this.identity.getKeyPair();
+ *
+ *                 if (senderKey && receiverPair) {
+ *                     const decrypted = await crypto.decFrom(
+ *                         data.content,
+ *                         { epub: senderKey.epub },
+ *                         receiverPair
+ *                     );
+ *
+ *                     onMessage({
+ *                         from: data.from,
+ *                         content: decrypted,
+ *                         timestamp: parseInt(data.timestamp)
+ *                     });
+ *                 }
+ *             }
+ *         });
+ *     }
+ *
+ *     async getMessageHistory(withUsername: string): Promise<MessageHistoryEntry[]> {
+ *         // Implementation here
+ *         return [];
  *     }
  * }
+ *
+ * // Usage
+ * const identity = new SHIP_00(config);
+ * await identity.login('alice', 'password123');
+ * await identity.publishPublicKey();
+ *
+ * const messaging = new SecureMessagingApp(identity);
+ * await messaging.sendMessage('bob', 'Hello Bob!');
  * ```
  */

package/dist/ship/interfaces/ISHIP_02.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * SHIP-02: Ethereum Address Derivation Interface
+ *
+ * @title ISHIP_02 - Deterministic Address Derivation
+ * @notice Interface for deriving Ethereum addresses from SHIP-00 identity
+ *
+ * ## Abstract
+ *
+ * This standard extends SHIP-00 to enable:
+ * - Deterministic Ethereum address derivation from identity keys
+ * - BIP-32/BIP-44 hierarchical deterministic (HD) wallet support
+ * - Stealth address generation for enhanced privacy
+ * - Multiple address management from single identity
+ * - Transaction signing with derived keys
+ *
+ * ## Specification
+ *
+ * Based on:
+ * - SHIP-00 for identity foundation
+ * - BIP-32 for hierarchical deterministic wallets
+ * - BIP-44 for multi-account hierarchy
+ * - Ethers.js for Ethereum operations
+ * - ECDH for stealth address generation
+ *
+ * ## Dependencies
+ *
+ * - SHIP-00: Identity and authentication foundation
+ * - ethers: Ethereum wallet and signing operations
+ *
+ * ## Usage
+ *
+ * SHIP-02 enables wallet functionality on top of SHIP-00 identity:
+ * ```typescript
+ * const identity = new SHIP_00({ gunOptions: { peers: ['...'] } });
+ * await identity.login('alice', 'password123');
+ *
+ * const addressDerivation = new SHIP_02(identity);
+ * await addressDerivation.initialize();
+ *
+ * const ethAddress = await addressDerivation.deriveEthereumAddress();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHIP_02_EventType = void 0;
+/**
+ * @notice Event types for SHIP-02 wallet operations
+ */
+var SHIP_02_EventType;
+(function (SHIP_02_EventType) {
+    SHIP_02_EventType["WALLET_CREATED"] = "walletCreated";
+    SHIP_02_EventType["ADDRESS_DERIVED"] = "addressDerived";
+    SHIP_02_EventType["TRANSACTION_SIGNED"] = "transactionSigned";
+    SHIP_02_EventType["MNEMONIC_GENERATED"] = "mnemonicGenerated";
+    SHIP_02_EventType["SYNC_COMPLETED"] = "syncCompleted";
+    SHIP_02_EventType["ERROR"] = "error";
+})(SHIP_02_EventType || (exports.SHIP_02_EventType = SHIP_02_EventType = {}));

package/dist/ship/interfaces/ISHIP_03.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * SHIP-03: Dual-Key Stealth Address Interface
+ *
+ * @title ISHIP_03 - Privacy-Preserving Stealth Addresses
+ * @notice Interface for ERC-5564 compatible stealth addresses
+ *
+ * ## Abstract
+ *
+ * This standard extends SHIP-00 and SHIP-02 to enable:
+ * - Dual-key stealth addresses (viewing + spending keys)
+ * - ERC-5564 / Fluidkey compatibility
+ * - Enhanced transaction privacy
+ * - Stealth address scanning and opening
+ * - Deterministic key derivation from SHIP-00 identity
+ *
+ * ## Specification
+ *
+ * Based on:
+ * - SHIP-00 for identity foundation
+ * - SHIP-02 for Ethereum address derivation
+ * - ERC-5564 for stealth address standard
+ * - Fluidkey Stealth Account Kit
+ * - ECDH for shared secret derivation
+ *
+ * ## Key Concepts
+ *
+ * **Viewing Key**: Used to scan blockchain for incoming stealth payments
+ * **Spending Key**: Used to spend funds received at stealth addresses
+ * **Ephemeral Key**: One-time key used by sender to generate stealth address
+ *
+ * ## Dependencies
+ *
+ * - SHIP-00: Identity and authentication foundation
+ * - SHIP-02: Ethereum wallet operations
+ * - @fluidkey/stealth-account-kit: ERC-5564 implementation
+ * - ethers: Ethereum operations
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const identity = new SHIP_00({ gunOptions: { peers: ['...'] } });
+ * await identity.login('alice', 'password123');
+ *
+ * const eth = new SHIP_02(identity);
+ * await eth.initialize();
+ *
+ * const stealth = new SHIP_03(identity, eth);
+ * await stealth.initialize();
+ *
+ * // Get stealth keys (derived from SHIP-00 identity)
+ * const keys = await stealth.getStealthKeys();
+ *
+ * // Generate stealth address for recipient
+ * const stealthAddr = await stealth.generateStealthAddress(
+ *   recipientViewingKey,
+ *   recipientSpendingKey
+ * );
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/gundb/db.js

@@ -79,11 +79,16 @@ const CONFIG = {
     },
 };
 class DataBase {
-    constructor(gun, appScope = "shogun") {
+    constructor(gun, appScope = "shogun", options) {
         this.user = null;
         this.onAuthCallbacks = [];
+        this.disableAutoRecall = false;
+        this.silent = false;
         // Initialize event emitter
         this.eventEmitter = new eventEmitter_1.EventEmitter();
+        // Set options
+        this.disableAutoRecall = options?.disableAutoRecall || false;
+        this.silent = options?.silent || false;
         // Validate Gun instance
         if (!gun) {
             throw new Error("Gun instance is required but was not provided");
@@ -101,7 +106,18 @@ class DataBase {
             throw new Error(`Gun instance is invalid: gun.on is not a function. Received gun.on type: ${typeof gun.on}`);
         }
         this.gun = gun;
-        this.user = this.gun.user().recall({ sessionStorage: true });
+        // Recall only if NOT disabled and there's a "pair" in sessionStorage
+        if (!this.disableAutoRecall &&
+            typeof sessionStorage !== "undefined" &&
+            sessionStorage.getItem("pair")) {
+            this.user = this.gun.user().recall({ sessionStorage: true });
+        }
+        else {
+            if (!this.silent && !this.disableAutoRecall) {
+                console.log("No pair found in sessionStorage, using gun.user()");
+            }
+            this.user = this.gun.user();
+        }
         this.subscribeToAuthEvents();
         this.crypto = crypto;
         this.sea = sea_1.default;
@@ -508,7 +524,13 @@ class DataBase {
                 }
                 // Attempt to recall user session
                 try {
-                    const recallResult = userInstance.recall({ sessionStorage: true });
+                    if (typeof sessionStorage !== "undefined" &&
+                        sessionStorage.getItem("pair")) {
+                        const recallResult = userInstance.recall({ sessionStorage: true });
+                    }
+                    else {
+                        const recallResult = userInstance;
+                    }
                     // console.log("recallResult", recallResult);
                 }
                 catch (recallError) {
@@ -1704,9 +1726,15 @@ class DataBase {
     /**
      * Recall user session
      */
-    recall() {
+    recall(options) {
         if (this.user) {
-            this.user.recall({ sessionStorage: true });
+            if (typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.user.recall({ sessionStorage: true });
+            }
+            else {
+                this.user;
+            }
         }
     }
     /**
@@ -1754,7 +1782,13 @@ class DataBase {
      */
     saveSession(session) {
         if (this.user) {
-            this.user.recall({ sessionStorage: true });
+            if (typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.user.recall({ sessionStorage: true });
+            }
+            else {
+                this.user;
+            }
         }
     }
     /**
@@ -1762,7 +1796,13 @@ class DataBase {
      */
     loadSession() {
         if (this.user) {
-            return this.user.recall({ sessionStorage: true });
+            if (typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                return this.user.recall({ sessionStorage: true });
+            }
+            else {
+                return this.user;
+            }
         }
         return null;
     }
@@ -1799,11 +1839,15 @@ class DataBase {
 exports.DataBase = DataBase;
 // Errors
 DataBase.Errors = GunErrors;
-const createGun = (config) => {
-    console.log("Creating Gun instance with config:", config);
-    console.log("Config peers:", config?.peers);
+const createGun = (config, silent) => {
+    if (!silent) {
+        console.log("Creating Gun instance with config:", config);
+        console.log("Config peers:", config?.peers);
+    }
     const gunInstance = (0, gun_1.default)(config);
-    console.log("Created Gun instance:", gunInstance);
+    if (!silent) {
+        console.log("Created Gun instance:", gunInstance);
+    }
     return gunInstance;
 };
 exports.createGun = createGun;

package/dist/src/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = exports.MessengerCLI = exports.SHIP_01 = void 0;
+exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = exports.WalletCLI = exports.MessengerCLI = exports.SHIP_03 = exports.SHIP_02 = exports.SHIP_01 = exports.SHIP_00 = void 0;
 const core_1 = require("./core");
 Object.defineProperty(exports, "ShogunCore", { enumerable: true, get: function () { return core_1.ShogunCore; } });
 const db_1 = require("./gundb/db");
@@ -42,9 +42,17 @@ __exportStar(require("./utils/errorHandler"), exports);
 __exportStar(require("./plugins"), exports);
 __exportStar(require("./interfaces/shogun"), exports);
 __exportStar(require("./config/simplified-config"), exports);
+var SHIP_00_1 = require("../ship/implementation/SHIP_00");
+Object.defineProperty(exports, "SHIP_00", { enumerable: true, get: function () { return SHIP_00_1.SHIP_00; } });
 var SHIP_01_1 = require("../ship/implementation/SHIP_01");
 Object.defineProperty(exports, "SHIP_01", { enumerable: true, get: function () { return SHIP_01_1.SHIP_01; } });
-// Export MessengerCLI only in Node.js environment (not browser)
+var SHIP_02_1 = require("../ship/implementation/SHIP_02");
+Object.defineProperty(exports, "SHIP_02", { enumerable: true, get: function () { return SHIP_02_1.SHIP_02; } });
+var SHIP_03_1 = require("../ship/implementation/SHIP_03");
+Object.defineProperty(exports, "SHIP_03", { enumerable: true, get: function () { return SHIP_03_1.SHIP_03; } });
+// Export CLI tools only in Node.js environment (not browser)
 // This prevents "readline is not a function" errors in browser builds
 var messenger_cli_1 = require("../ship/examples/messenger-cli");
 Object.defineProperty(exports, "MessengerCLI", { enumerable: true, get: function () { return messenger_cli_1.MessengerCLI; } });
+var wallet_cli_1 = require("../ship/examples/wallet-cli");
+Object.defineProperty(exports, "WalletCLI", { enumerable: true, get: function () { return wallet_cli_1.WalletCLI; } });

package/dist/src/managers/CoreInitializer.js

@@ -34,7 +34,7 @@ class CoreInitializer {
             };
         }
         // Initialize storage
-        this.core.storage = new storage_1.ShogunStorage();
+        this.core.storage = new storage_1.ShogunStorage(config.silent);
         // Setup error handler
         errorHandler_1.ErrorHandler.addListener((error) => {
             this.core.emit("error", {
@@ -62,25 +62,35 @@ class CoreInitializer {
      * Initialize Gun instance
      */
     async initializeGun(config) {
-        console.log("Initialize Gun instance", config);
+        if (!config.silent) {
+            console.log("Initialize Gun instance", config);
+        }
         try {
             if (config.gunInstance && config.gunOptions === undefined) {
-                console.log("Using provided Gun instance");
+                if (!config.silent) {
+                    console.log("Using provided Gun instance");
+                }
                 this.core._gun = config.gunInstance;
             }
             else if (config.gunOptions && config.gunInstance === undefined) {
-                console.log("Creating new Gun instance");
-                this.core._gun = (0, gundb_1.createGun)(config.gunOptions);
+                if (!config.silent) {
+                    console.log("Creating new Gun instance");
+                }
+                this.core._gun = (0, gundb_1.createGun)(config.gunOptions, config.silent);
             }
             else if (config.gunInstance && config.gunOptions) {
                 // Both provided, prefer gunInstance
-                console.log("Both gunInstance and gunOptions provided, using gunInstance");
+                if (!config.silent) {
+                    console.log("Both gunInstance and gunOptions provided, using gunInstance");
+                }
                 this.core._gun = config.gunInstance;
             }
             else {
                 // Neither provided, create a default Gun instance for testing
-                console.log("No Gun instance or options provided, creating default instance");
-                this.core._gun = (0, gundb_1.createGun)({ peers: config.gunOptions?.peers || [] });
+                if (!config.silent) {
+                    console.log("No Gun instance or options provided, creating default instance");
+                }
+                this.core._gun = (0, gundb_1.createGun)({ peers: config.gunOptions?.peers || [] }, config.silent);
             }
         }
         catch (error) {
@@ -90,8 +100,10 @@ class CoreInitializer {
             throw new Error(`Failed to create Gun instance: ${error}`);
         }
         try {
-            console.log("Initialize Gun instance", this.core.gun);
-            this.core.db = new gundb_1.DataBase(this.core._gun, config.gunOptions?.scope || "");
+            if (!config.silent) {
+                console.log("Initialize Gun instance", this.core.gun);
+            }
+            this.core.db = new gundb_1.DataBase(this.core._gun, config.gunOptions?.scope || "", { disableAutoRecall: config.disableAutoRecall, silent: config.silent });
             // Note: user is a getter that returns _user, so we don't need to assign it
         }
         catch (error) {
@@ -106,7 +118,15 @@ class CoreInitializer {
      */
     async initializeGunUser() {
         try {
-            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            // Skip recall if disabled in config
+            if (!this.core.config.disableAutoRecall &&
+                typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            }
+            else {
+                this.core._user = this.core.gun.user();
+            }
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
@@ -115,7 +135,15 @@ class CoreInitializer {
             throw new Error(`Failed to initialize Gun user: ${error}`);
         }
         this.core.gun.on("auth", (user) => {
-            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            // Skip recall if disabled in config
+            if (!this.core.config.disableAutoRecall &&
+                typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            }
+            else {
+                this.core._user = this.core.gun.user();
+            }
             this.core.emit("auth:login", {
                 userPub: user.pub,
                 method: "password",
@@ -149,7 +177,7 @@ class CoreInitializer {
      */
     setupWalletDerivation() {
         this.core.gun.on("auth", async (user) => {
-            if (!user)
+            if (!user.is)
                 return;
             const priv = user._?.sea?.epriv;
             const pub = user._?.sea?.epub;