shogun-core 1.2.0 → 1.2.3

package/dist/types/gundb/gun.d.ts

@@ -1,25 +1,21 @@
 /**
  * GunDB class with enhanced features:
- * - Dynamic auth token usage
- * - Concurrency-safe authentication
  * - Dynamic peer linking
  * - Support for remove/unset operations
+ * - Direct authentication through Gun.user()
  */
 import { IGunUserInstance, IGunInstance, IGunChain } from "gun";
 import { GunRxJS } from "./rxjs-integration";
 import * as GunErrors from "./errors";
 import * as crypto from "./crypto";
 import * as utils from "./utils";
-import AuthManager from "./models/auth/auth";
 declare class GunDB {
     gun: IGunInstance<any>;
     user: IGunUserInstance<any> | null;
     crypto: typeof crypto;
     utils: typeof utils;
-    auth: AuthManager;
     node: IGunChain<any, IGunInstance<any>, IGunInstance<any>, string>;
     private readonly onAuthCallbacks;
-    private _authenticating;
     private _rxjs?;
     constructor(gun: IGunInstance<any>, appScope?: string);
     private subscribeToAuthEvents;
@@ -107,14 +103,14 @@ declare class GunDB {
      */
     remove(path: string): Promise<any>;
     /**
-     * Signs up a new user using AuthManager
+     * Signs up a new user using direct Gun authentication
      * @param username Username
      * @param password Password
      * @returns Promise resolving to signup result
      */
     signUp(username: string, password: string): Promise<any>;
     /**
-     * Logs in a user using AuthManager
+     * Logs in a user using direct Gun authentication
      * @param username Username
      * @param password Password
      * @param callback Optional callback for login result
@@ -122,10 +118,8 @@ declare class GunDB {
      */
     login(username: string, password: string, callback?: (result: any) => void): Promise<any>;
     private _savePair;
-    private isAuthenticating;
-    private _setAuthenticating;
     /**
-     * Logs out the current user using AuthManager
+     * Logs out the current user using direct Gun authentication
      */
     logout(): void;
     /**

package/dist/types/plugins/index.d.ts

@@ -3,9 +3,9 @@ export type { ShogunPlugin, PluginManager } from "../types/plugin";
 export { Webauthn } from "./webauthn/webauthn";
 export { WebauthnPlugin } from "./webauthn/webauthnPlugin";
 export type { WebauthnPluginInterface } from "./webauthn/types";
-export { Web3Connector } from "./ethereum/web3Connector";
-export { Web3ConnectorPlugin } from "./ethereum/web3ConnectorPlugin";
-export type { Web3ConectorPluginInterface } from "./ethereum/types";
-export { NostrConnector } from "./bitcoin/nostrConnector";
-export { NostrConnectorPlugin } from "./bitcoin/nostrConnectorPlugin";
-export type { NostrConnectorPluginInterface, NostrConnectorCredentials, NostrConnectorKeyPair, NostrConnectorConfig, AlbyProvider, NostrProvider, } from "./bitcoin/types";
+export { Web3Connector } from "./web3/web3Connector";
+export { Web3ConnectorPlugin } from "./web3/web3ConnectorPlugin";
+export type { Web3ConectorPluginInterface } from "./web3/types";
+export { NostrConnector } from "./nostr/nostrConnector";
+export { NostrConnectorPlugin } from "./nostr/nostrConnectorPlugin";
+export type { NostrConnectorPluginInterface, NostrConnectorCredentials, NostrConnectorKeyPair, NostrConnectorConfig, AlbyProvider, NostrProvider, } from "./nostr/types";

package/dist/types/shogun.js

@@ -25,9 +25,9 @@ var CorePlugins;
     /** WebAuthn plugin */
     CorePlugins["WebAuthn"] = "webauthn";
     /** Ethereum plugin */
-    CorePlugins["Ethereum"] = "ethereum";
+    CorePlugins["Web3"] = "web3";
     /** Bitcoin wallet plugin */
-    CorePlugins["Bitcoin"] = "bitcoin";
+    CorePlugins["Nostr"] = "nostr";
 })(CorePlugins || (exports.CorePlugins = CorePlugins = {}));
 /**
  * Authentication states for the state machine

package/dist/types/types/shogun.d.ts

@@ -27,11 +27,11 @@ export declare enum CorePlugins {
     /** WebAuthn plugin */
     WebAuthn = "webauthn",
     /** Ethereum plugin */
-    Ethereum = "ethereum",
+    Web3 = "web3",
     /** Bitcoin wallet plugin */
-    Bitcoin = "bitcoin"
+    Nostr = "nostr"
 }
-export type AuthMethod = "password" | "webauthn" | "ethereum" | "bitcoin";
+export type AuthMethod = "password" | "webauthn" | "web3" | "nostr";
 export interface AuthResult {
     success: boolean;
     error?: string;
@@ -104,38 +104,20 @@ export interface ShogunSDKConfig {
     gunInstance?: IGunInstance<any>;
     scope?: string;
     peers?: string[];
-    /** WebAuthn configuration */
     webauthn?: WebauthnConfig;
-    /** MetaMask configuration */
-    ethereum?: {
-        /** Enable MetaMask */
+    web3?: {
         enabled?: boolean;
     };
-    /** Bitcoin wallet configuration */
-    bitcoin?: {
-        /** Enable Bitcoin wallet */
+    nostr?: {
         enabled?: boolean;
-        /** Bitcoin network to use (default: mainnet) */
-        network?: "mainnet" | "testnet";
-        /** Use API for verification (default: false) */
-        useApi?: boolean;
-        /** API URL for verification */
-        apiUrl?: string;
     };
-    /** Logging configuration */
     logging?: LoggingConfig;
-    /** Timeout configuration in milliseconds */
     timeouts?: {
-        /** Login timeout in milliseconds (default: 15000) */
         login?: number;
-        /** Signup timeout in milliseconds (default: 20000) */
         signup?: number;
-        /** General operation timeout in milliseconds (default: 30000) */
         operation?: number;
     };
-    /** Plugin configuration */
     plugins?: {
-        /** List of plugins to automatically register on initialization */
         autoRegister?: ShogunPlugin[];
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shogun-core",
-  "version": "1.2.0",
+  "version": "1.2.3",
   "description": "SHOGUN SDK - Core library for Shogun SDK",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/dist/gundb/models/auth/auth.js

@@ -1,207 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const state_machine_1 = require("./state-machine");
-// Simple helper function to replace app_scoped
-function app_scoped(text, scope) {
-    return `${scope}_${text}`;
-}
-/** An auth manager that wraps gun.user logic. */
-class AuthManager {
-    static INITIAL_STATE = state_machine_1.states.disconnected;
-    static state = (0, state_machine_1.use_machine)(state_machine_1.auth_state_machine, AuthManager.INITIAL_STATE);
-    static instance;
-    gundb;
-    app_scope = "shogun";
-    /** Returns the validated alias and password information. This will also be scoped using app_scope */
-    async validate(alias, password) {
-        if (password.length < 8)
-            throw new Error("Passwords in gun must be more than 8 characters long!");
-        if (alias.length < 1)
-            throw new Error("User name must be more than 0 characters long!");
-        const validated_alias = app_scoped(alias, this.app_scope);
-        const validated_password = app_scoped(password, this.app_scope);
-        return { alias: validated_alias, password: validated_password };
-    }
-    /** A new AuthManager. */
-    constructor(gundb, appScope = "shogun") {
-        if (AuthManager.instance) {
-            this.gundb = AuthManager.instance.gundb;
-            this.app_scope = AuthManager.instance.app_scope;
-            return AuthManager.instance;
-        }
-        this.gundb = gundb;
-        this.app_scope = appScope;
-        AuthManager.instance = this;
-    }
-    /** Gets the user chain, if authenticated. */
-    get chain() {
-        const pair = this.pair({ strict: true });
-        return this.gundb.gun.get(pair.pub);
-    }
-    pair(options = {}) {
-        const user = this.gundb.gun.user()._;
-        if ("sea" in user) {
-            return user.sea;
-        }
-        if (options.strict) {
-            throw new Error("Failed to get user pair! User is not authenticated");
-        }
-        return undefined;
-    }
-    /**
-     * Generate a new gun user pair using alias and password.
-     *
-     * @param alias - The user alias.
-     * @param password - The user password.
-     * @returns A promise that resolves with gun ack or rejects with gun ack on errors.
-     */
-    create = async ({ alias, password, }) => {
-        // Note: throws if state transitions is not possible.
-        AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.create));
-        // attempt to create user.
-        try {
-            const res = await new Promise((resolve, reject) => {
-                this.gundb.gun.user().create(alias, password, (ack) => {
-                    if ("err" in ack) {
-                        reject(ack);
-                        return;
-                    }
-                    resolve(ack);
-                });
-            });
-            // creation success.
-            AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.success));
-            return res;
-        }
-        catch (err) {
-            // creation failure.
-            AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.fail, err));
-            throw err;
-        }
-    };
-    /**
-     * Authenicate existing gun user using either a pair or a alias/password combination.
-     * @returns A promise that resolves with gun ack or rejects with gun ack on errors.
-     */
-    auth = async (info) => {
-        AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.authenticate));
-        // attempt to authenticate user.
-        try {
-            const res = await new Promise((resolve, reject) => {
-                if ("pub" in info) {
-                    // Use auth with the pair directly to avoid type errors
-                    // @ts-ignore - Ignoring type errors with GunDB's auth method
-                    this.gundb.gun.user().auth(info, (ack) => {
-                        if ("err" in ack) {
-                            reject(new Error(ack.err));
-                            return;
-                        }
-                        else
-                            resolve(ack);
-                    });
-                }
-                else {
-                    // @ts-ignore - Ignoring type errors with GunDB's auth method
-                    this.gundb.gun.user().auth(info.alias, info.password, (ack) => {
-                        if ("err" in ack) {
-                            reject(new Error(ack.err));
-                            return;
-                        }
-                        else
-                            resolve(ack);
-                    });
-                }
-            });
-            // on auth success
-            AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.success));
-            return res;
-        }
-        catch (err) {
-            // on auth error
-            AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.fail));
-            throw err;
-        }
-    };
-    /**
-     * Un-authenticates the currently authenticated gun user.
-     */
-    leave = async () => {
-        // check if state transition is possible.
-        AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.disconnect));
-        // attempt log out.
-        try {
-            const res = await new Promise((resolve, reject) => {
-                this.gundb.gun.user().leave();
-                if (this.pair()?.pub) {
-                    reject({ err: "User leave failed!" });
-                    return;
-                }
-                resolve({ success: true });
-            });
-            // on success.
-            AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.success));
-            return res;
-        }
-        catch (err) {
-            // on fail.
-            AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.fail));
-            throw err;
-        }
-    };
-    /**
-     * A simple default certificate that will allow everybody to write to the users graph, as long as the key or path contains their public key.
-     */
-    certify() {
-        // Currently not implemented - needs to be added to the crypto module
-        return null;
-    }
-    /**
-     * Start wallet initialization process
-     */
-    startWalletInit() {
-        AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.wallet_init_start));
-    }
-    /**
-     * Mark wallet initialization as successful
-     */
-    walletInitSuccess() {
-        AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.wallet_init_success));
-    }
-    /**
-     * Mark wallet initialization as failed
-     */
-    walletInitFail(error) {
-        AuthManager.state.set(new state_machine_1.StateMachineEvent(state_machine_1.events.wallet_init_fail, error));
-    }
-    /**
-     * Wait for authentication to complete
-     */
-    async waitForAuthentication(timeoutMs = 10000) {
-        return AuthManager.state.waitForState(state_machine_1.states.authorized, timeoutMs);
-    }
-    /**
-     * Wait for wallet to be ready
-     */
-    async waitForWalletReady(timeoutMs = 15000) {
-        return AuthManager.state.waitForState(state_machine_1.states.wallet_ready, timeoutMs);
-    }
-    /**
-     * Check if user is authenticated
-     */
-    isAuthenticated() {
-        return AuthManager.state.isAuthenticated();
-    }
-    /**
-     * Check if wallet is ready
-     */
-    isWalletReady() {
-        return AuthManager.state.isWalletReady();
-    }
-    /**
-     * Get current authentication state
-     */
-    getCurrentState() {
-        return AuthManager.state.getCurrentState();
-    }
-}
-exports.default = AuthManager;

package/dist/gundb/models/auth/state-machine.js

@@ -1,216 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.events = exports.states = exports.StateMachineEvent = void 0;
-exports.use_machine = use_machine;
-exports.auth_state_machine = auth_state_machine;
-/** A state machine event with optional data */
-class StateMachineEvent {
-    type;
-    data;
-    constructor(type, data = {}) {
-        this.type = type;
-        this.data = data;
-    }
-}
-exports.StateMachineEvent = StateMachineEvent;
-/**
- *
- * @param machine - A machine function that defines state transitions.
- * @param initial - The initial state of the machine.
- */
-function use_machine(machine, initial) {
-    let state = initial;
-    let subs = new Map();
-    let stateWaiters = new Map();
-    function subscribe(cb) {
-        const id = crypto.randomUUID();
-        subs.set(id, cb);
-        cb(state);
-        return () => {
-            subs.delete(id);
-        };
-    }
-    function set(event) {
-        const previousState = state;
-        state = machine(state, event);
-        // Notify subscribers
-        for (const sub of subs.values()) {
-            sub(state);
-        }
-        // Notify state waiters
-        const waiters = stateWaiters.get(state);
-        if (waiters) {
-            waiters.forEach((resolve) => resolve(true));
-            stateWaiters.delete(state);
-        }
-    }
-    function getCurrentState() {
-        return state;
-    }
-    function waitForState(targetState, timeoutMs = 10000) {
-        return new Promise((resolve) => {
-            // If already in target state, resolve immediately
-            if (state === targetState) {
-                resolve(true);
-                return;
-            }
-            // Add to waiters
-            if (!stateWaiters.has(targetState)) {
-                stateWaiters.set(targetState, []);
-            }
-            stateWaiters.get(targetState).push(resolve);
-            // Set timeout
-            setTimeout(() => {
-                const waiters = stateWaiters.get(targetState);
-                if (waiters) {
-                    const index = waiters.indexOf(resolve);
-                    if (index > -1) {
-                        waiters.splice(index, 1);
-                        if (waiters.length === 0) {
-                            stateWaiters.delete(targetState);
-                        }
-                    }
-                }
-                resolve(false);
-            }, timeoutMs);
-        });
-    }
-    function isAuthenticated() {
-        return (state === exports.states.authorized ||
-            state === exports.states.wallet_initializing ||
-            state === exports.states.wallet_ready);
-    }
-    function isWalletReady() {
-        return state === exports.states.wallet_ready;
-    }
-    return {
-        /**
-         * Subscribe to state updates.
-         * @returns an unsubscriber */
-        subscribe,
-        /** attempt to update the state machine */
-        set,
-        /** Get the current state */
-        getCurrentState,
-        /** Wait for a specific state */
-        waitForState,
-        /** Check if user is authenticated */
-        isAuthenticated,
-        /** Check if wallet is ready */
-        isWalletReady,
-    };
-}
-/** Possible states that the auth-manager can be in. */
-exports.states = {
-    /** The user is in an un-busy and unauthorized state.*/
-    disconnected: "disconnected",
-    /** A user is currently being created. */
-    creating: "creating",
-    /** A user is currently being authorized. */
-    pending: "pending",
-    /** The user is in an un-busy and authorized state. */
-    authorized: "authorized",
-    /** The user is currently logging out. */
-    leaving: "leaving",
-    /** Wallet initialization is in progress. */
-    wallet_initializing: "wallet_initializing",
-    /** Wallet is ready and available. */
-    wallet_ready: "wallet_ready",
-};
-/** Possible events that the auth-manager can take. */
-exports.events = {
-    create: "create",
-    authenticate: "authenticate",
-    disconnect: "disconnect",
-    fail: "fail",
-    success: "success",
-    wallet_init_start: "wallet_init_start",
-    wallet_init_success: "wallet_init_success",
-    wallet_init_fail: "wallet_init_fail",
-};
-class StateTransitionError extends Error {
-    state;
-    event;
-    constructor(message, state, event) {
-        super(message);
-        this.state = state;
-        this.event = event;
-    }
-}
-/**
- * Defines possible transitions from the states in the auth manager.
- *
- * @param state - The current state.
- * @param event The event that has happend.
- * @returns The new state.
- */
-function auth_state_machine(state, event) {
-    const transition_error = new StateTransitionError("Not a valid state transition", state, event.type);
-    switch (state) {
-        // User is disconnected and unbusy
-        case exports.states.disconnected:
-            if (event.type === exports.events.create) {
-                return exports.states.creating;
-            }
-            if (event.type === exports.events.authenticate) {
-                return exports.states.pending;
-            }
-            throw transition_error;
-        // User is creating and busy
-        case exports.states.creating:
-            if (event.type === exports.events.fail) {
-                return exports.states.disconnected;
-            }
-            if (event.type === exports.events.success) {
-                return exports.states.disconnected;
-            }
-            throw transition_error;
-        // User is logging in and busy
-        case exports.states.pending:
-            if (event.type === exports.events.fail) {
-                return exports.states.disconnected;
-            }
-            if (event.type === exports.events.success) {
-                return exports.states.authorized;
-            }
-            throw transition_error;
-        // User is authorized and unbusy
-        case exports.states.authorized:
-            if (event.type === exports.events.disconnect) {
-                return exports.states.leaving;
-            }
-            if (event.type === exports.events.wallet_init_start) {
-                return exports.states.wallet_initializing;
-            }
-            throw transition_error;
-        // User is leaving and busy
-        case exports.states.leaving:
-            if (event.type === exports.events.fail) {
-                return exports.states.authorized;
-            }
-            if (event.type === exports.events.success) {
-                return exports.states.disconnected;
-            }
-            throw transition_error;
-        // Wallet is being initialized
-        case exports.states.wallet_initializing:
-            if (event.type === exports.events.wallet_init_success) {
-                return exports.states.wallet_ready;
-            }
-            if (event.type === exports.events.wallet_init_fail) {
-                return exports.states.authorized;
-            }
-            if (event.type === exports.events.disconnect) {
-                return exports.states.leaving;
-            }
-            throw transition_error;
-        // Wallet is ready
-        case exports.states.wallet_ready:
-            if (event.type === exports.events.disconnect) {
-                return exports.states.leaving;
-            }
-            throw transition_error;
-        default:
-            throw transition_error;
-    }
-}

package/dist/gundb/models/streams.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.on_stream = on_stream;
-exports.to_unique = to_unique;
-exports.to_node = to_node;
-/**
- *
- * Only Firefox implements async iterable on ReadableStream. This will add polyfill.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream#browser_compatibility
- */
-(function enable_async_iterator_polyfill() {
-    ReadableStream.prototype[Symbol.asyncIterator] = async function* () {
-        const reader = this.getReader();
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    return;
-                yield value;
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    };
-})();
-/**
- *
- * Wraps .on call in a stream. Cancelling the stream will unsubscribe from updates from gun.
- *
- * **Usage:**
- * ```
- * const stream = on_stream(node)
- * for await (const chunk of stream) {
- *    // Do something with each 'chunk'
- * }
- * ```
- */
-function on_stream(chain) {
-    let ev;
-    const stream = new ReadableStream({
-        start(controller) {
-            console.log("stream started");
-            chain.on(function (value, key, _, event) {
-                ev = event;
-                console.log(`from stream, ${key}`);
-                controller.enqueue({ value, key, chain: this });
-            });
-        },
-        cancel() {
-            console.log("stream cancelled");
-            if (!ev) {
-                // TODO log
-                return;
-            }
-            ev.off();
-        },
-    });
-    return stream;
-}
-/**
- *
- * Takes an incoming stream, but only issues updates if the data changes from valid data to null data.
- * You can use this to keep a list in sync with the gun state. If data is tombstoned, it can be removed from the list.
- *
- * **Example:**
- * ```
- * const map = new Map();
- * const items = [];
- * const stream = on_stream(node).pipeThrough(unique_transformer());
- * for await (const chunk of stream) {
- *      chunk.value === null ? map.delete(chunk.key) : map.set(chunk.key, chunk.chain);
-        items.splice(0, items.length, ...map.values());
- * }
- * ```
- */
-function to_unique() {
-    const map = new Map();
-    const transformer = new TransformStream({
-        transform(chuck, controller) {
-            if (!map.has(chuck.key)) {
-                pass(controller, chuck);
-                return;
-            }
-            const old_value = map.get(chuck.key);
-            if (chuck.value === null && old_value !== null) {
-                pass(controller, chuck);
-                return;
-            }
-            if (chuck.value !== null && old_value === null) {
-                pass(controller, chuck);
-                return;
-            }
-            function pass(controller, chuck) {
-                map.set(chuck.key, chuck.chain);
-                controller.enqueue(chuck);
-            }
-        },
-    });
-    return transformer;
-}
-/**
- * Transoforms a stream of gun chains into a stream of gun nodes.
- */
-function to_node(target) {
-    const transformer = new TransformStream({
-        transform(chunk, controller) {
-            const new_chunk = chunk.chain
-                ? { value: chunk.value, key: chunk.key, node: new target(chunk.chain) }
-                : { value: chunk.value, key: chunk.key, node: chunk.chain };
-            controller.enqueue(new_chunk);
-        },
-    });
-    return transformer;
-}