shogun-core 1.2.7 → 1.2.8

package/dist/plugins/webauthn/webauthnPlugin.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebauthnPlugin = void 0;
 const base_1 = require("../base");
 const webauthn_1 = require("./webauthn");
+const webauthnSigner_1 = require("./webauthnSigner");
 const logger_1 = require("../../utils/logger");
 const ethers_1 = require("ethers");
 const errorHandler_1 = require("../../utils/errorHandler");
@@ -14,6 +15,7 @@ class WebauthnPlugin extends base_1.BasePlugin {
     version = "1.0.0";
     description = "Provides WebAuthn authentication functionality for ShogunCore";
     webauthn = null;
+    signer = null;
     /**
      * @inheritdoc
      */
@@ -21,13 +23,15 @@ class WebauthnPlugin extends base_1.BasePlugin {
         super.initialize(core);
         // Inizializziamo il modulo WebAuthn
         this.webauthn = new webauthn_1.Webauthn(core.gun);
-        (0, logger_1.log)("WebAuthn plugin initialized");
+        this.signer = new webauthnSigner_1.WebAuthnSigner(this.webauthn);
+        (0, logger_1.log)("WebAuthn plugin initialized with signer support");
     }
     /**
      * @inheritdoc
      */
     destroy() {
         this.webauthn = null;
+        this.signer = null;
         super.destroy();
         (0, logger_1.log)("WebAuthn plugin destroyed");
     }
@@ -42,6 +46,17 @@ class WebauthnPlugin extends base_1.BasePlugin {
         }
         return this.webauthn;
     }
+    /**
+     * Assicura che il signer sia inizializzato
+     * @private
+     */
+    assertSigner() {
+        this.assertInitialized();
+        if (!this.signer) {
+            throw new Error("WebAuthn signer not initialized");
+        }
+        return this.signer;
+    }
     /**
      * @inheritdoc
      */
@@ -78,6 +93,144 @@ class WebauthnPlugin extends base_1.BasePlugin {
     async removeDevice(username, credentialId, credentials) {
         return this.assertWebauthn().removeDevice(username, credentialId, credentials);
     }
+    /**
+     * @inheritdoc
+     */
+    async createSigningCredential(username) {
+        try {
+            (0, logger_1.log)(`Creating signing credential for user: ${username}`);
+            return await this.assertSigner().createSigningCredential(username);
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error creating signing credential: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    createAuthenticator(credentialId) {
+        try {
+            (0, logger_1.log)(`Creating authenticator for credential: ${credentialId}`);
+            return this.assertSigner().createAuthenticator(credentialId);
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error creating authenticator: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    async createDerivedKeyPair(credentialId, username, extra) {
+        try {
+            (0, logger_1.log)(`Creating derived key pair for credential: ${credentialId}`);
+            return await this.assertSigner().createDerivedKeyPair(credentialId, username, extra);
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error creating derived key pair: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    async signWithDerivedKeys(data, credentialId, username, extra) {
+        try {
+            (0, logger_1.log)(`Signing data with derived keys for credential: ${credentialId}`);
+            return await this.assertSigner().signWithDerivedKeys(data, credentialId, username, extra);
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error signing with derived keys: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    getSigningCredential(credentialId) {
+        return this.assertSigner().getCredential(credentialId);
+    }
+    /**
+     * @inheritdoc
+     */
+    listSigningCredentials() {
+        return this.assertSigner().listCredentials();
+    }
+    /**
+     * @inheritdoc
+     */
+    removeSigningCredential(credentialId) {
+        return this.assertSigner().removeCredential(credentialId);
+    }
+    // === CONSISTENCY METHODS ===
+    /**
+     * Creates a Gun user from WebAuthn signing credential
+     * This ensures the SAME user is created as with normal approach
+     */
+    async createGunUserFromSigningCredential(credentialId, username) {
+        try {
+            const core = this.assertInitialized();
+            (0, logger_1.log)(`Creating Gun user from signing credential: ${credentialId}`);
+            return await this.assertSigner().createGunUser(credentialId, username, core.gun);
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error creating Gun user from signing credential: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Get the Gun user public key for a signing credential
+     */
+    getGunUserPubFromSigningCredential(credentialId) {
+        return this.assertSigner().getGunUserPub(credentialId);
+    }
+    /**
+     * Get the hashed credential ID (for consistency checking)
+     */
+    getHashedCredentialId(credentialId) {
+        return this.assertSigner().getHashedCredentialId(credentialId);
+    }
+    /**
+     * Verify consistency between oneshot and normal approaches
+     * This ensures both approaches create the same Gun user
+     */
+    async verifyConsistency(credentialId, username, expectedUserPub) {
+        try {
+            (0, logger_1.log)(`Verifying consistency for credential: ${credentialId}`);
+            return await this.assertSigner().verifyConsistency(credentialId, username, expectedUserPub);
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error verifying consistency: ${error.message}`);
+            return { consistent: false };
+        }
+    }
+    /**
+     * Complete oneshot workflow that creates the SAME Gun user as normal approach
+     * This is the recommended method for oneshot signing with full consistency
+     */
+    async setupConsistentOneshotSigning(username) {
+        try {
+            (0, logger_1.log)(`Setting up consistent oneshot signing for: ${username}`);
+            // 1. Create signing credential (with consistent hashing)
+            const credential = await this.createSigningCredential(username);
+            // 2. Create authenticator
+            const authenticator = this.createAuthenticator(credential.id);
+            // 3. Create Gun user (same as normal approach)
+            const gunUser = await this.createGunUserFromSigningCredential(credential.id, username);
+            return {
+                credential,
+                authenticator,
+                gunUser,
+                pub: credential.pub,
+                hashedCredentialId: credential.hashedCredentialId,
+            };
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error setting up consistent oneshot signing: ${error.message}`);
+            throw error;
+        }
+    }
     /**
      * Login with WebAuthn
      * This is the recommended method for WebAuthn authentication

package/dist/plugins/webauthn/webauthnSigner.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAuthnSigner = void 0;
+const webauthn_1 = require("./webauthn");
+const p256_1 = require("@noble/curves/p256");
+const sha256_1 = require("@noble/hashes/sha256");
+const logger_1 = require("../../utils/logger");
+const derive_1 = __importDefault(require("../../gundb/derive"));
+const ethers_1 = require("ethers");
+/**
+ * Base64URL encoding utilities
+ */
+const base64url = {
+    encode: function (buffer) {
+        const bytes = new Uint8Array(buffer);
+        return btoa(String.fromCharCode(...bytes))
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=/g, "");
+    },
+    decode: function (str) {
+        str = str.replace(/-/g, "+").replace(/_/g, "/");
+        while (str.length % 4)
+            str += "=";
+        const binary = atob(str);
+        return new Uint8Array(binary.split("").map((c) => c.charCodeAt(0)));
+    },
+};
+/**
+ * WebAuthn Signer - Provides oneshot signing functionality
+ * Similar to webauthn.js but integrated with our architecture
+ * CONSISTENT with normal WebAuthn approach
+ */
+class WebAuthnSigner {
+    webauthn;
+    credentials = new Map();
+    constructor(webauthn) {
+        this.webauthn = webauthn || new webauthn_1.Webauthn();
+    }
+    /**
+     * Creates a new WebAuthn credential for signing
+     * Similar to webauthn.js create functionality but CONSISTENT with normal approach
+     */
+    async createSigningCredential(username) {
+        try {
+            const credential = (await navigator.credentials.create({
+                publicKey: {
+                    challenge: crypto.getRandomValues(new Uint8Array(32)),
+                    rp: {
+                        id: window.location.hostname === "localhost"
+                            ? "localhost"
+                            : window.location.hostname,
+                        name: "Shogun Wallet",
+                    },
+                    user: {
+                        id: new TextEncoder().encode(username),
+                        name: username,
+                        displayName: username,
+                    },
+                    // Use the same algorithms as webauthn.js for SEA compatibility
+                    pubKeyCredParams: [
+                        { type: "public-key", alg: -7 }, // ECDSA, P-256 curve, for signing
+                        { type: "public-key", alg: -25 }, // ECDH, P-256 curve, for creating shared secrets
+                        { type: "public-key", alg: -257 },
+                    ],
+                    authenticatorSelection: {
+                        userVerification: "preferred",
+                    },
+                    timeout: 60000,
+                    attestation: "none",
+                },
+            }));
+            if (!credential) {
+                throw new Error("Failed to create WebAuthn credential");
+            }
+            // Extract public key in the same way as webauthn.js
+            const response = credential.response;
+            const publicKey = response.getPublicKey();
+            if (!publicKey) {
+                throw new Error("Failed to get public key from credential");
+            }
+            const rawKey = new Uint8Array(publicKey);
+            (0, logger_1.logDebug)("Raw public key bytes:", rawKey);
+            // Extract coordinates like webauthn.js (slice positions may need adjustment)
+            const xCoord = rawKey.slice(27, 59);
+            const yCoord = rawKey.slice(59, 91);
+            const x = base64url.encode(xCoord);
+            const y = base64url.encode(yCoord);
+            const pub = `${x}.${y}`;
+            // CONSISTENCY: Use the same hashing approach as normal WebAuthn
+            const hashedCredentialId = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(credential.id));
+            const signingCredential = {
+                id: credential.id,
+                rawId: credential.rawId,
+                publicKey: { x, y },
+                pub,
+                hashedCredentialId, // This ensures consistency
+            };
+            // Store credential for later use
+            this.credentials.set(credential.id, signingCredential);
+            (0, logger_1.logDebug)("Created signing credential:", signingCredential);
+            return signingCredential;
+        }
+        catch (error) {
+            (0, logger_1.logError)("Error creating signing credential:", error);
+            throw new Error(`Failed to create signing credential: ${error.message}`);
+        }
+    }
+    /**
+     * Creates an authenticator function compatible with SEA.sign
+     * This is the key function that makes it work like webauthn.js
+     */
+    createAuthenticator(credentialId) {
+        const credential = this.credentials.get(credentialId);
+        if (!credential) {
+            throw new Error(`Credential ${credentialId} not found`);
+        }
+        return async (data) => {
+            try {
+                const challenge = new TextEncoder().encode(JSON.stringify(data));
+                const options = {
+                    challenge,
+                    rpId: window.location.hostname === "localhost"
+                        ? "localhost"
+                        : window.location.hostname,
+                    userVerification: "preferred",
+                    allowCredentials: [
+                        {
+                            type: "public-key",
+                            id: credential.rawId,
+                        },
+                    ],
+                    timeout: 60000,
+                };
+                const assertion = (await navigator.credentials.get({
+                    publicKey: options,
+                }));
+                if (!assertion) {
+                    throw new Error("WebAuthn assertion failed");
+                }
+                (0, logger_1.logDebug)("WebAuthn assertion successful:", { options, assertion });
+                return assertion.response;
+            }
+            catch (error) {
+                (0, logger_1.logError)("WebAuthn assertion error:", error);
+                throw error;
+            }
+        };
+    }
+    /**
+     * Creates a derived key pair from WebAuthn credential
+     * CONSISTENT with normal approach: uses hashedCredentialId as password
+     */
+    async createDerivedKeyPair(credentialId, username, extra) {
+        const credential = this.credentials.get(credentialId);
+        if (!credential) {
+            throw new Error(`Credential ${credentialId} not found`);
+        }
+        try {
+            // CONSISTENCY: Use the same approach as normal WebAuthn
+            // Use hashedCredentialId as password (same as normal approach)
+            const derivedKeys = await (0, derive_1.default)(credential.hashedCredentialId, // This is the key change!
+            extra, { includeP256: true });
+            return {
+                pub: derivedKeys.pub,
+                priv: derivedKeys.priv,
+                epub: derivedKeys.epub,
+                epriv: derivedKeys.epriv,
+            };
+        }
+        catch (error) {
+            (0, logger_1.logError)("Error deriving keys from WebAuthn credential:", error);
+            throw error;
+        }
+    }
+    /**
+     * Creates a Gun user from WebAuthn credential
+     * This ensures the SAME user is created as with normal approach
+     */
+    async createGunUser(credentialId, username, gunInstance) {
+        const credential = this.credentials.get(credentialId);
+        if (!credential) {
+            throw new Error(`Credential ${credentialId} not found`);
+        }
+        try {
+            // Use the SAME approach as normal WebAuthn
+            return new Promise((resolve) => {
+                gunInstance
+                    .user()
+                    .create(username, credential.hashedCredentialId, (ack) => {
+                    if (ack.err) {
+                        // Try to login if user already exists
+                        gunInstance
+                            .user()
+                            .auth(username, credential.hashedCredentialId, (authAck) => {
+                            if (authAck.err) {
+                                resolve({ success: false, error: authAck.err });
+                            }
+                            else {
+                                const userPub = authAck.pub;
+                                // Update credential with Gun user pub
+                                credential.gunUserPub = userPub;
+                                this.credentials.set(credentialId, credential);
+                                resolve({ success: true, userPub });
+                            }
+                        });
+                    }
+                    else {
+                        // User created, now login
+                        gunInstance
+                            .user()
+                            .auth(username, credential.hashedCredentialId, (authAck) => {
+                            if (authAck.err) {
+                                resolve({ success: false, error: authAck.err });
+                            }
+                            else {
+                                const userPub = authAck.pub;
+                                // Update credential with Gun user pub
+                                credential.gunUserPub = userPub;
+                                this.credentials.set(credentialId, credential);
+                                resolve({ success: true, userPub });
+                            }
+                        });
+                    }
+                });
+            });
+        }
+        catch (error) {
+            (0, logger_1.logError)("Error creating Gun user:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Signs data using WebAuthn + derived keys
+     * This provides a hybrid approach: WebAuthn for user verification + derived keys for actual signing
+     * CONSISTENT with normal approach
+     */
+    async signWithDerivedKeys(data, credentialId, username, extra) {
+        try {
+            // First, verify user with WebAuthn
+            const authenticator = this.createAuthenticator(credentialId);
+            await authenticator(data); // This verifies the user
+            // Then use derived keys for actual signing (CONSISTENT approach)
+            const keyPair = await this.createDerivedKeyPair(credentialId, username, extra);
+            // Create signature using P-256 (same as SEA)
+            const message = JSON.stringify(data);
+            const messageHash = (0, sha256_1.sha256)(new TextEncoder().encode(message));
+            // Convert base64url private key to bytes
+            const privKeyBytes = base64url.decode(keyPair.priv);
+            // Sign with P-256
+            const signature = p256_1.p256.sign(messageHash, privKeyBytes);
+            // Format like SEA signature
+            const seaSignature = {
+                m: message,
+                s: base64url.encode(signature.toCompactRawBytes()),
+            };
+            return "SEA" + JSON.stringify(seaSignature);
+        }
+        catch (error) {
+            (0, logger_1.logError)("Error signing with derived keys:", error);
+            throw error;
+        }
+    }
+    /**
+     * Get the Gun user public key for a credential
+     * This allows checking if the same user would be created
+     */
+    getGunUserPub(credentialId) {
+        const credential = this.credentials.get(credentialId);
+        return credential?.gunUserPub;
+    }
+    /**
+     * Get the hashed credential ID (for consistency checking)
+     */
+    getHashedCredentialId(credentialId) {
+        const credential = this.credentials.get(credentialId);
+        return credential?.hashedCredentialId;
+    }
+    /**
+     * Check if this credential would create the same Gun user as normal approach
+     */
+    async verifyConsistency(credentialId, username, expectedUserPub) {
+        const credential = this.credentials.get(credentialId);
+        if (!credential) {
+            return { consistent: false };
+        }
+        // The derived keys should be the same as normal approach
+        const derivedKeys = await this.createDerivedKeyPair(credentialId, username);
+        return {
+            consistent: expectedUserPub ? derivedKeys.pub === expectedUserPub : true,
+            actualUserPub: derivedKeys.pub,
+            expectedUserPub,
+        };
+    }
+    /**
+     * Get credential by ID
+     */
+    getCredential(credentialId) {
+        return this.credentials.get(credentialId);
+    }
+    /**
+     * List all stored credentials
+     */
+    listCredentials() {
+        return Array.from(this.credentials.values());
+    }
+    /**
+     * Remove a credential
+     */
+    removeCredential(credentialId) {
+        return this.credentials.delete(credentialId);
+    }
+}
+exports.WebAuthnSigner = WebAuthnSigner;
+exports.default = WebAuthnSigner;

package/dist/storage/storage.js

@@ -15,17 +15,13 @@ class ShogunStorage {
      */
     constructor() {
         this.store = new Map();
-        // Controlla se siamo in ambiente di test
         this.isTestMode = process.env.NODE_ENV === "test";
         this.useLocalStorage = false;
-        // Check if localStorage is available
         if (typeof localStorage !== "undefined" && !this.isTestMode) {
             try {
-                // Test localStorage access
                 localStorage.setItem("_shogun_test", "_shogun_test");
                 localStorage.removeItem("_shogun_test");
                 this.useLocalStorage = true;
-                // Load existing keypair if available
                 const storedPair = localStorage.getItem("shogun_keypair");
                 if (storedPair) {
                     this.store.set("keypair", JSON.parse(storedPair));
@@ -106,7 +102,6 @@ class ShogunStorage {
         try {
             const parsedValue = JSON.parse(value);
             this.store.set(key, parsedValue);
-            // Also save to localStorage in browser environments
             if (this.useLocalStorage) {
                 try {
                     localStorage.setItem(key, value);
@@ -119,9 +114,7 @@ class ShogunStorage {
             }
         }
         catch (error) {
-            // If not valid JSON, store as string
             this.store.set(key, value);
-            // Also save to localStorage in browser environments
             if (this.useLocalStorage) {
                 try {
                     localStorage.setItem(key, value);
@@ -140,7 +133,6 @@ class ShogunStorage {
      */
     removeItem(key) {
         this.store.delete(key);
-        // Also remove from localStorage in browser environments
         if (this.useLocalStorage) {
             try {
                 localStorage.removeItem(key);

package/dist/types/core.d.ts

@@ -1,40 +1,27 @@
-import { GunDB } from "./gundb";
+import { GunInstance } from "./gundb";
 import { GunRxJS } from "./gundb/rxjs-integration";
 import { ShogunError } from "./utils/errorHandler";
 import { ShogunStorage } from "./storage/storage";
 import { IShogunCore, ShogunSDKConfig, AuthResult, SignUpResult, LoggingConfig, PluginCategory, AuthMethod } from "./types/shogun";
 import { ethers } from "ethers";
 import { ShogunPlugin } from "./types/plugin";
-import { IGunUserInstance, IGunInstance } from "gun";
-import "gun/sea";
-export { RelayVerifier } from "./contracts/utils";
+import { Gun, SEA, IGunUserInstance, IGunInstance } from "./gundb/gun-es/gun-es";
 export * from "./utils/errorHandler";
+export * from "./gundb";
 export * from "./gundb/rxjs-integration";
 export * from "./plugins";
-export * from "./contracts/entryPoint";
-export * from "./contracts/utils";
-export * from "./contracts/registry";
-export * from "./contracts/relay";
-export type * from "./contracts/entryPoint";
-export type * from "./contracts/relay";
-export type * from "./contracts/registry";
-export type * from "./contracts/base";
-export type * from "./contracts/utils";
 export type * from "./types/plugin";
 export type * from "./utils/errorHandler";
+export type { IGunUserInstance, IGunInstance } from "./gundb/gun-es/gun-es";
+export { SEA, Gun };
 export * from "./types/shogun";
-export { GunDB } from "./gundb";
-export { derive } from "./gundb";
-export type { DeriveOptions } from "./gundb";
-export { Web3Connector } from "./plugins/web3/web3Connector";
-export { Webauthn } from "./plugins/webauthn/webauthn";
 export { ShogunStorage } from "./storage/storage";
 export { ShogunEventEmitter } from "./types/events";
 /**
  * Main ShogunCore class - implements the IShogunCore interface
  *
  * This is the primary entry point for the Shogun SDK, providing access to:
- * - Decentralized database (GunDB)
+ * - Decentralized database (GunInstance)
  * - Authentication methods (traditional, WebAuthn, MetaMask)
  * - Plugin system for extensibility
  * - RxJS integration for reactive programming
@@ -42,33 +29,22 @@ export { ShogunEventEmitter } from "./types/events";
  * @since 2.0.0
  */
 export declare class ShogunCore implements IShogunCore {
-    /** Current API version - used for deprecation warnings and migration guidance */
     static readonly API_VERSION = "2.0.0";
-    /** Gun database instance - access through gundb.gun for consistency */
     private _gun;
-    /** Gun user instance */
     private _user;
-    /** GunDB wrapper - the primary interface for Gun operations */
-    gundb: GunDB;
-    /** Storage implementation */
+    gundb: GunInstance;
     storage: ShogunStorage;
-    /** Event emitter for SDK events */
     private readonly eventEmitter;
-    /** Ethereum provider */
     provider?: ethers.Provider;
-    /** SDK configuration */
     config: ShogunSDKConfig;
-    /** RxJS integration */
     rx: GunRxJS;
-    /** Plugin registry */
     private readonly plugins;
-    /** Current authentication method */
     private currentAuthMethod?;
     /**
      * Initialize the Shogun SDK
      * @param config - SDK Configuration object
      * @description Creates a new instance of ShogunCore with the provided configuration.
-     * Initializes all required components including storage, event emitter, GunDB connection,
+     * Initializes all required components including storage, event emitter, GunInstance connection,
      * and plugin system.
      */
     constructor(config: ShogunSDKConfig);
@@ -145,13 +121,13 @@ export declare class ShogunCore implements IShogunCore {
     /**
      * Check if user is logged in
      * @returns {boolean} True if user is logged in, false otherwise
-     * @description Verifies authentication status by checking GunDB login state
+     * @description Verifies authentication status by checking GunInstance login state
      * and presence of authentication credentials in storage
      */
     isLoggedIn(): boolean;
     /**
      * Perform user logout
-     * @description Logs out the current user from GunDB and emits logout event.
+     * @description Logs out the current user from GunInstance and emits logout event.
      * If user is not authenticated, the logout operation is ignored.
      */
     logout(): void;

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

@@ -6,3 +6,4 @@ import "gun/lib/store";
 import "gun/lib/rindexed";
 import "gun/lib/webrtc";
 export { Gun, SEA };
+export type { IGunUserInstance, IGunInstance } from "gun/types";

package/dist/types/gundb/{instance.d.ts → gunInstance.d.ts}

@@ -10,7 +10,7 @@ import * as GunErrors from "./errors";
 import * as crypto from "./crypto";
 import * as utils from "./utils";
 import { DeriveOptions } from "./derive";
-declare class GunDB {
+declare class GunInstance {
     gun: IGunInstance<any>;
     user: IGunUserInstance<any> | null;
     crypto: typeof crypto;
@@ -256,4 +256,4 @@ declare class GunDB {
     deriveAll(password: any, extra?: any): Promise<any>;
     static Errors: typeof GunErrors;
 }
-export { GunDB };
+export { GunInstance };

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

@@ -1,5 +1,2 @@
-export { GunDB } from "./instance";
+export { GunInstance } from "./gunInstance";
 export { Gun, SEA } from "./gun-es/gun-es";
-export { default as derive } from "./derive";
-export type { DeriveOptions } from "./derive";
-export { getId, getPub, getTargetPub, getUUID, getSet, qs, getIndexedObjectFromArray, getArrayFromIndexedObject, app_scoped, } from "./utils";