holosphere 1.1.21 → 1.3.0-alpha3

package/nostr-utils-shim.js

@@ -0,0 +1,125 @@
+/**
+ * Nostr-compatible cryptographic utilities for HoloSphere v1.3
+ * Provides key generation, encoding, and conversion using secp256k1
+ */
+
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
+import { bech32 } from '@scure/base';
+
+function generatePrivateKey() {
+    const privKey = secp256k1.utils.randomPrivateKey();
+    return bytesToHex(privKey);
+}
+
+function getPublicKey(privateKeyHex) {
+    // Get compressed public key (33 bytes) then extract x-only (32 bytes)
+    const pubBytes = secp256k1.getPublicKey(privateKeyHex, true);
+    // x-only pubkey is the compressed key minus the prefix byte
+    return bytesToHex(pubBytes.slice(1));
+}
+
+function getPublicKeyFromBytes(privateKeyBytes) {
+    const pubBytes = secp256k1.getPublicKey(privateKeyBytes, true);
+    return bytesToHex(pubBytes.slice(1));
+}
+
+function hexToNpub(hex) {
+    const data = hexToBytes(hex);
+    const words = bech32.toWords(data);
+    return bech32.encode('npub', words, 1500);
+}
+
+function hexToNsec(hex) {
+    const data = hexToBytes(hex);
+    const words = bech32.toWords(data);
+    return bech32.encode('nsec', words, 1500);
+}
+
+function npubToHex(npub) {
+    const { words } = bech32.decode(npub, 1500);
+    const data = bech32.fromWords(words);
+    return bytesToHex(new Uint8Array(data));
+}
+
+function nsecToHex(nsec) {
+    const { words } = bech32.decode(nsec, 1500);
+    const data = bech32.fromWords(words);
+    return bytesToHex(new Uint8Array(data));
+}
+
+function parseNsecOrHex(input) {
+    if (!input || typeof input !== 'string') return null;
+    input = input.trim();
+    if (input.startsWith('nsec1')) {
+        try {
+            return nsecToHex(input);
+        } catch (e) {
+            return null;
+        }
+    }
+    // Validate hex
+    if (/^[0-9a-f]{64}$/i.test(input)) {
+        return input.toLowerCase();
+    }
+    return null;
+}
+
+function parseNpubOrHex(input) {
+    if (!input || typeof input !== 'string') return null;
+    input = input.trim();
+    if (input.startsWith('npub1')) {
+        try {
+            return npubToHex(input);
+        } catch (e) {
+            return null;
+        }
+    }
+    if (/^[0-9a-f]{64}$/i.test(input)) {
+        return input.toLowerCase();
+    }
+    return null;
+}
+
+function shortenPubKey(pubkey, len = 8) {
+    if (!pubkey) return '';
+    return pubkey.slice(0, len) + '...' + pubkey.slice(-len);
+}
+
+function shortenNpub(npub, len = 8) {
+    if (!npub) return '';
+    return npub.slice(0, len + 5) + '...' + npub.slice(-len);
+}
+
+function generateNonce() {
+    const bytes = new Uint8Array(32);
+    if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.getRandomValues) {
+        globalThis.crypto.getRandomValues(bytes);
+    } else {
+        // Simple fallback - not cryptographically secure but functional
+        for (let i = 0; i < 32; i++) {
+            bytes[i] = Math.floor(Math.random() * 256);
+        }
+    }
+    return bytesToHex(bytes);
+}
+
+export const nostrUtils = {
+    generatePrivateKey,
+    getPublicKey,
+    getPublicKeyFromBytes,
+    parseNsecOrHex,
+    parseNpubOrHex,
+    hexToNpub,
+    hexToNsec,
+    npubToHex,
+    nsecToHex,
+    hexToBytes,
+    bytesToHex,
+    shortenPubKey,
+    shortenNpub,
+    generateNonce
+};
+
+export { hexToBytes, bytesToHex };
+export default nostrUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.1.21",
+  "version": "1.3.0-alpha3",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "module": "holosphere.js",
@@ -20,10 +20,12 @@
   "author": "Roberto Valenti",
   "license": "GPL-3.0-or-later",
   "dependencies": {
+    "@noble/curves": "^1.8.0",
+    "@noble/hashes": "^1.8.0",
+    "@scure/base": "^1.2.0",
     "ajv": "^8.12.0",
     "gun": "^0.2020.1240",
-    "h3-js": "^4.1.0",
-    "openai": "^4.85.1"
+    "h3-js": "^4.1.0"
   },
   "devDependencies": {
     "esbuild": "^0.25.12",
@@ -53,6 +55,10 @@
     "compute.js",
     "utils.js",
     "hexlib.js",
+    "nostr-utils-shim.js",
+    "subscriptions-shim.js",
+    "registry-shim.js",
+    "handshake-shim.js",
     "README.md",
     "LICENSE",
     "FEDERATION.md"
@@ -99,6 +105,9 @@
   "peerDependenciesMeta": {
     "openai": {
       "optional": true
+    },
+    "gun": {
+      "optional": false
     }
   }
 }

package/registry-shim.js

@@ -0,0 +1,109 @@
+/**
+ * GunDB-based registry for HoloSphere v1.3
+ * Provides capability storage for federation handshakes
+ */
+
+export const registry = {
+    /**
+     * Store an inbound capability for a holon
+     * @param {object} client - The HoloSphere instance
+     * @param {string} appName - Application name
+     * @param {string} holonId - Holon identifier
+     * @param {object} capability - Capability data to store
+     * @returns {Promise<{ success: boolean }>}
+     */
+    async storeInboundCapability(client, appName, holonId, capability) {
+        try {
+            const gun = client.gun || client;
+            const id = (capability.token || 'cap') + '_' + Date.now();
+            const payload = JSON.stringify({ ...capability, id, storedAt: Date.now() });
+
+            return new Promise((resolve) => {
+                gun.get(appName).get('_capabilities').get(holonId).get(id).put(payload, (ack) => {
+                    if (ack.err) {
+                        console.warn('[registry] Failed to store capability:', ack.err);
+                        resolve({ success: false, error: ack.err });
+                    } else {
+                        resolve({ success: true, id });
+                    }
+                });
+            });
+        } catch (error) {
+            console.error('[registry] Error storing capability:', error);
+            return { success: false, error: error.message };
+        }
+    },
+
+    /**
+     * Get inbound capabilities for a holon
+     * @param {object} client - The HoloSphere instance
+     * @param {string} appName - Application name
+     * @param {string} holonId - Holon identifier
+     * @returns {Promise<Array<object>>}
+     */
+    async getInboundCapabilities(client, appName, holonId) {
+        try {
+            const gun = client.gun || client;
+            return new Promise((resolve) => {
+                const caps = [];
+                const capPath = gun.get(appName).get('_capabilities').get(holonId);
+
+                capPath.once((data) => {
+                    if (!data) {
+                        resolve([]);
+                        return;
+                    }
+
+                    const keys = Object.keys(data).filter(k => k !== '_');
+                    if (keys.length === 0) {
+                        resolve([]);
+                        return;
+                    }
+
+                    let received = 0;
+                    capPath.map().once((itemData, key) => {
+                        received++;
+                        if (itemData && key !== '_') {
+                            try {
+                                const parsed = typeof itemData === 'string' ? JSON.parse(itemData) : itemData;
+                                caps.push(parsed);
+                            } catch (e) {
+                                // skip unparseable
+                            }
+                        }
+                        if (received >= keys.length) {
+                            resolve(caps);
+                        }
+                    });
+                });
+            });
+        } catch (error) {
+            console.error('[registry] Error getting capabilities:', error);
+            return [];
+        }
+    },
+
+    /**
+     * Remove an inbound capability
+     * @param {object} client - The HoloSphere instance
+     * @param {string} appName - Application name
+     * @param {string} holonId - Holon identifier
+     * @param {string} capabilityId - Capability ID to remove
+     * @returns {Promise<boolean>}
+     */
+    async removeInboundCapability(client, appName, holonId, capabilityId) {
+        try {
+            const gun = client.gun || client;
+            return new Promise((resolve) => {
+                gun.get(appName).get('_capabilities').get(holonId).get(capabilityId).put(null, (ack) => {
+                    resolve(!ack.err);
+                });
+            });
+        } catch (error) {
+            console.error('[registry] Error removing capability:', error);
+            return false;
+        }
+    }
+};
+
+export default registry;

package/subscriptions-shim.js

@@ -0,0 +1,117 @@
+/**
+ * GunDB-based subscription wrapper for HoloSphere v1.3
+ * Provides v2-compatible subscription API backed by Gun.js
+ */
+
+/**
+ * Build a lens path string
+ * @param {string} appName - Application name
+ * @param {string} holonId - Holon identifier
+ * @param {string} lens - Lens name
+ * @returns {string} Combined path
+ */
+export function buildLensPath(appName, holonId, lens) {
+    return `${appName}/${holonId}/${lens}`;
+}
+
+/**
+ * Parse a lens path into its components
+ * @param {string} path - The path to parse
+ * @returns {{ appName: string, holonId: string, lens: string } | null}
+ */
+function parseLensPath(path) {
+    const parts = path.split('/');
+    if (parts.length < 3) return null;
+    return {
+        appName: parts[0],
+        holonId: parts[1],
+        lens: parts.slice(2).join('/')
+    };
+}
+
+export const subscriptions = {
+    /**
+     * Create a subscription to a GunDB path
+     * @param {object} client - The HoloSphere instance
+     * @param {string} path - The lens path (appName/holonId/lens)
+     * @param {function} callback - Callback for data changes
+     * @param {object} [options] - Subscription options
+     * @param {boolean} [options.realtimeOnly] - Only fire for new changes (not initial data)
+     * @param {boolean} [options.resolveHolograms] - Whether to resolve hologram references
+     * @param {string} [options.appname] - Application name override
+     * @returns {{ unsubscribe: () => void, stop: () => void }}
+     */
+    createSubscription(client, path, callback, options = {}) {
+        const parsed = parseLensPath(path);
+        if (!parsed) {
+            console.warn('[subscriptions] Invalid path:', path);
+            return { unsubscribe: () => {}, stop: () => {} };
+        }
+
+        const gun = client.gun || client;
+        const dataPath = gun.get(parsed.appName).get(parsed.holonId).get(parsed.lens);
+        let active = true;
+        let initialLoadComplete = false;
+
+        // Track initial data load for realtimeOnly mode
+        if (options.realtimeOnly) {
+            // First do a .once() pass to mark initial data as loaded
+            dataPath.once(() => {
+                setTimeout(() => { initialLoadComplete = true; }, 100);
+            });
+        } else {
+            initialLoadComplete = true;
+        }
+
+        const handler = dataPath.map().on(async (data, key) => {
+            if (!active) return;
+            if (options.realtimeOnly && !initialLoadComplete) return;
+            if (!data || key === '_') return;
+
+            try {
+                let parsed;
+                if (typeof data === 'string') {
+                    try {
+                        parsed = JSON.parse(data);
+                    } catch (e) {
+                        parsed = data;
+                    }
+                } else {
+                    // Clean Gun metadata
+                    const cleaned = { ...data };
+                    delete cleaned._;
+                    parsed = cleaned;
+                }
+
+                // Resolve holograms if requested and client supports it
+                if (options.resolveHolograms && client.isHologram && client.isHologram(parsed)) {
+                    try {
+                        const resolved = await client.resolveHologram(parsed, { followHolograms: true });
+                        if (resolved && resolved !== parsed) {
+                            callback(resolved, key);
+                            return;
+                        }
+                    } catch (e) {
+                        console.warn('[subscriptions] Failed to resolve hologram:', e);
+                    }
+                }
+
+                callback(parsed, key);
+            } catch (e) {
+                console.warn('[subscriptions] Error processing subscription data:', e);
+            }
+        });
+
+        const unsub = () => {
+            active = false;
+            dataPath.off();
+        };
+
+        return {
+            unsubscribe: unsub,
+            stop: unsub
+        };
+    }
+};
+
+export default { subscriptions, buildLensPath };