holosphere 1.0.2 → 1.0.4

package/hexlib.js

@@ -0,0 +1,332 @@
+// Generated code -- CC0 -- No Rights Reserved -- http://www.redblobgames.com/grids/hexagons/
+export class Point {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+}
+export class Hex {
+    constructor(q, r, s) {
+        this.q = q;
+        this.r = r;
+        this.s = s;
+        if (Math.round(q + r + s) !== 0)
+            throw "q + r + s must be 0";
+    }
+    add(b) {
+        return new Hex(this.q + b.q, this.r + b.r, this.s + b.s);
+    }
+    subtract(b) {
+        return new Hex(this.q - b.q, this.r - b.r, this.s - b.s);
+    }
+    scale(k) {
+        return new Hex(this.q * k, this.r * k, this.s * k);
+    }
+    rotateLeft() {
+        return new Hex(-this.s, -this.q, -this.r);
+    }
+    rotateRight() {
+        return new Hex(-this.r, -this.s, -this.q);
+    }
+    static direction(direction) {
+        return Hex.directions[direction];
+    }
+    neighbor(direction) {
+        return this.add(Hex.direction(direction));
+    }
+    diagonalNeighbor(direction) {
+        return this.add(Hex.diagonals[direction]);
+    }
+    len() {
+        return (Math.abs(this.q) + Math.abs(this.r) + Math.abs(this.s)) / 2;
+    }
+    distance(b) {
+        return this.subtract(b).len();
+    }
+    round() {
+        var qi = Math.round(this.q);
+        var ri = Math.round(this.r);
+        var si = Math.round(this.s);
+        var q_diff = Math.abs(qi - this.q);
+        var r_diff = Math.abs(ri - this.r);
+        var s_diff = Math.abs(si - this.s);
+        if (q_diff > r_diff && q_diff > s_diff) {
+            qi = -ri - si;
+        }
+        else if (r_diff > s_diff) {
+            ri = -qi - si;
+        }
+        else {
+            si = -qi - ri;
+        }
+        return new Hex(qi, ri, si);
+    }
+    lerp(b, t) {
+        return new Hex(this.q * (1.0 - t) + b.q * t, this.r * (1.0 - t) + b.r * t, this.s * (1.0 - t) + b.s * t);
+    }
+    linedraw(b) {
+        var N = this.distance(b);
+        var a_nudge = new Hex(this.q + 1e-06, this.r + 1e-06, this.s - 2e-06);
+        var b_nudge = new Hex(b.q + 1e-06, b.r + 1e-06, b.s - 2e-06);
+        var results = [];
+        var step = 1.0 / Math.max(N, 1);
+        for (var i = 0; i <= N; i++) {
+            results.push(a_nudge.lerp(b_nudge, step * i).round());
+        }
+        return results;
+    }
+}
+Hex.directions = [new Hex(1, 0, -1), new Hex(1, -1, 0), new Hex(0, -1, 1), new Hex(-1, 0, 1), new Hex(-1, 1, 0), new Hex(0, 1, -1)];
+Hex.diagonals = [new Hex(2, -1, -1), new Hex(1, -2, 1), new Hex(-1, -1, 2), new Hex(-2, 1, 1), new Hex(-1, 2, -1), new Hex(1, 1, -2)];
+export class OffsetCoord {
+    constructor(col, row) {
+        this.col = col;
+        this.row = row;
+    }
+    static qoffsetFromCube(offset, h) {
+        var col = h.q;
+        var row = h.r + (h.q + offset * (h.q & 1)) / 2;
+        if (offset !== OffsetCoord.EVEN && offset !== OffsetCoord.ODD) {
+            throw "offset must be EVEN (+1) or ODD (-1)";
+        }
+        return new OffsetCoord(col, row);
+    }
+    static qoffsetToCube(offset, h) {
+        var q = h.col;
+        var r = h.row - (h.col + offset * (h.col & 1)) / 2;
+        var s = -q - r;
+        if (offset !== OffsetCoord.EVEN && offset !== OffsetCoord.ODD) {
+            throw "offset must be EVEN (+1) or ODD (-1)";
+        }
+        return new Hex(q, r, s);
+    }
+    static roffsetFromCube(offset, h) {
+        var col = h.q + (h.r + offset * (h.r & 1)) / 2;
+        var row = h.r;
+        if (offset !== OffsetCoord.EVEN && offset !== OffsetCoord.ODD) {
+            throw "offset must be EVEN (+1) or ODD (-1)";
+        }
+        return new OffsetCoord(col, row);
+    }
+    static roffsetToCube(offset, h) {
+        var q = h.col - (h.row + offset * (h.row & 1)) / 2;
+        var r = h.row;
+        var s = -q - r;
+        if (offset !== OffsetCoord.EVEN && offset !== OffsetCoord.ODD) {
+            throw "offset must be EVEN (+1) or ODD (-1)";
+        }
+        return new Hex(q, r, s);
+    }
+}
+OffsetCoord.EVEN = 1;
+OffsetCoord.ODD = -1;
+export class DoubledCoord {
+    constructor(col, row) {
+        this.col = col;
+        this.row = row;
+    }
+    static qdoubledFromCube(h) {
+        var col = h.q;
+        var row = 2 * h.r + h.q;
+        return new DoubledCoord(col, row);
+    }
+    qdoubledToCube() {
+        var q = this.col;
+        var r = (this.row - this.col) / 2;
+        var s = -q - r;
+        return new Hex(q, r, s);
+    }
+    static rdoubledFromCube(h) {
+        var col = 2 * h.q + h.r;
+        var row = h.r;
+        return new DoubledCoord(col, row);
+    }
+    rdoubledToCube() {
+        var q = (this.col - this.row) / 2;
+        var r = this.row;
+        var s = -q - r;
+        return new Hex(q, r, s);
+    }
+}
+export class Orientation {
+    constructor(f0, f1, f2, f3, b0, b1, b2, b3, start_angle) {
+        this.f0 = f0;
+        this.f1 = f1;
+        this.f2 = f2;
+        this.f3 = f3;
+        this.b0 = b0;
+        this.b1 = b1;
+        this.b2 = b2;
+        this.b3 = b3;
+        this.start_angle = start_angle;
+    }
+}
+export class Layout {
+    constructor(orientation, size, origin) {
+        this.orientation = orientation;
+        this.size = size;
+        this.origin = origin;
+    }
+    hexToPixel(h) {
+        var M = this.orientation;
+        var size = this.size;
+        var origin = this.origin;
+        var x = (M.f0 * h.q + M.f1 * h.r) * size.x;
+        var y = (M.f2 * h.q + M.f3 * h.r) * size.y;
+        return new Point(x + origin.x, y + origin.y);
+    }
+    pixelToHex(p) {
+        var M = this.orientation;
+        var size = this.size;
+        var origin = this.origin;
+        var pt = new Point((p.x - origin.x) / size.x, (p.y - origin.y) / size.y);
+        var q = M.b0 * pt.x + M.b1 * pt.y;
+        var r = M.b2 * pt.x + M.b3 * pt.y;
+        return new Hex(q, r, -q - r);
+    }
+    hexCornerOffset(corner) {
+        var M = this.orientation;
+        var size = this.size;
+        var angle = 2.0 * Math.PI * (M.start_angle - corner) / 6.0;
+        return new Point(size.x * Math.cos(angle), size.y * Math.sin(angle));
+    }
+    polygonCorners(h) {
+        var corners = [];
+        var center = this.hexToPixel(h);
+        for (var i = 0; i < 6; i++) {
+            var offset = this.hexCornerOffset(i);
+            corners.push(new Point(center.x + offset.x, center.y + offset.y));
+        }
+        return corners;
+    }
+}
+Layout.pointy = new Orientation(Math.sqrt(3.0), Math.sqrt(3.0) / 2.0, 0.0, 3.0 / 2.0, Math.sqrt(3.0) / 3.0, -1.0 / 3.0, 0.0, 2.0 / 3.0, 0.5);
+Layout.flat = new Orientation(3.0 / 2.0, 0.0, Math.sqrt(3.0) / 2.0, Math.sqrt(3.0), 2.0 / 3.0, 0.0, -1.0 / 3.0, Math.sqrt(3.0) / 3.0, 0.0);
+class Tests {
+    constructor() { }
+    static equalHex(name, a, b) {
+        if (!(a.q === b.q && a.s === b.s && a.r === b.r)) {
+            complain(name);
+        }
+    }
+    static equalOffsetcoord(name, a, b) {
+        if (!(a.col === b.col && a.row === b.row)) {
+            complain(name);
+        }
+    }
+    static equalDoubledcoord(name, a, b) {
+        if (!(a.col === b.col && a.row === b.row)) {
+            complain(name);
+        }
+    }
+    static equalInt(name, a, b) {
+        if (!(a === b)) {
+            complain(name);
+        }
+    }
+    static equalHexArray(name, a, b) {
+        Tests.equalInt(name, a.length, b.length);
+        for (var i = 0; i < a.length; i++) {
+            Tests.equalHex(name, a[i], b[i]);
+        }
+    }
+    static testHexArithmetic() {
+        Tests.equalHex("hex_add", new Hex(4, -10, 6), new Hex(1, -3, 2).add(new Hex(3, -7, 4)));
+        Tests.equalHex("hex_subtract", new Hex(-2, 4, -2), new Hex(1, -3, 2).subtract(new Hex(3, -7, 4)));
+    }
+    static testHexDirection() {
+        Tests.equalHex("hex_direction", new Hex(0, -1, 1), Hex.direction(2));
+    }
+    static testHexNeighbor() {
+        Tests.equalHex("hex_neighbor", new Hex(1, -3, 2), new Hex(1, -2, 1).neighbor(2));
+    }
+    static testHexDiagonal() {
+        Tests.equalHex("hex_diagonal", new Hex(-1, -1, 2), new Hex(1, -2, 1).diagonalNeighbor(3));
+    }
+    static testHexDistance() {
+        Tests.equalInt("hex_distance", 7, new Hex(3, -7, 4).distance(new Hex(0, 0, 0)));
+    }
+    static testHexRotateRight() {
+        Tests.equalHex("hex_rotate_right", new Hex(1, -3, 2).rotateRight(), new Hex(3, -2, -1));
+    }
+    static testHexRotateLeft() {
+        Tests.equalHex("hex_rotate_left", new Hex(1, -3, 2).rotateLeft(), new Hex(-2, -1, 3));
+    }
+    static testHexRound() {
+        var a = new Hex(0.0, 0.0, 0.0);
+        var b = new Hex(1.0, -1.0, 0.0);
+        var c = new Hex(0.0, -1.0, 1.0);
+        Tests.equalHex("hex_round 1", new Hex(5, -10, 5), new Hex(0.0, 0.0, 0.0).lerp(new Hex(10.0, -20.0, 10.0), 0.5).round());
+        Tests.equalHex("hex_round 2", a.round(), a.lerp(b, 0.499).round());
+        Tests.equalHex("hex_round 3", b.round(), a.lerp(b, 0.501).round());
+        Tests.equalHex("hex_round 4", a.round(), new Hex(a.q * 0.4 + b.q * 0.3 + c.q * 0.3, a.r * 0.4 + b.r * 0.3 + c.r * 0.3, a.s * 0.4 + b.s * 0.3 + c.s * 0.3).round());
+        Tests.equalHex("hex_round 5", c.round(), new Hex(a.q * 0.3 + b.q * 0.3 + c.q * 0.4, a.r * 0.3 + b.r * 0.3 + c.r * 0.4, a.s * 0.3 + b.s * 0.3 + c.s * 0.4).round());
+    }
+    static testHexLinedraw() {
+        Tests.equalHexArray("hex_linedraw", [new Hex(0, 0, 0), new Hex(0, -1, 1), new Hex(0, -2, 2), new Hex(1, -3, 2), new Hex(1, -4, 3), new Hex(1, -5, 4)], new Hex(0, 0, 0).linedraw(new Hex(1, -5, 4)));
+    }
+    static testLayout() {
+        var h = new Hex(3, 4, -7);
+        var flat = new Layout(Layout.flat, new Point(10.0, 15.0), new Point(35.0, 71.0));
+        Tests.equalHex("layout", h, flat.pixelToHex(flat.hexToPixel(h)).round());
+        var pointy = new Layout(Layout.pointy, new Point(10.0, 15.0), new Point(35.0, 71.0));
+        Tests.equalHex("layout", h, pointy.pixelToHex(pointy.hexToPixel(h)).round());
+    }
+    static testOffsetRoundtrip() {
+        var a = new Hex(3, 4, -7);
+        var b = new OffsetCoord(1, -3);
+        Tests.equalHex("conversion_roundtrip even-q", a, OffsetCoord.qoffsetToCube(OffsetCoord.EVEN, OffsetCoord.qoffsetFromCube(OffsetCoord.EVEN, a)));
+        Tests.equalOffsetcoord("conversion_roundtrip even-q", b, OffsetCoord.qoffsetFromCube(OffsetCoord.EVEN, OffsetCoord.qoffsetToCube(OffsetCoord.EVEN, b)));
+        Tests.equalHex("conversion_roundtrip odd-q", a, OffsetCoord.qoffsetToCube(OffsetCoord.ODD, OffsetCoord.qoffsetFromCube(OffsetCoord.ODD, a)));
+        Tests.equalOffsetcoord("conversion_roundtrip odd-q", b, OffsetCoord.qoffsetFromCube(OffsetCoord.ODD, OffsetCoord.qoffsetToCube(OffsetCoord.ODD, b)));
+        Tests.equalHex("conversion_roundtrip even-r", a, OffsetCoord.roffsetToCube(OffsetCoord.EVEN, OffsetCoord.roffsetFromCube(OffsetCoord.EVEN, a)));
+        Tests.equalOffsetcoord("conversion_roundtrip even-r", b, OffsetCoord.roffsetFromCube(OffsetCoord.EVEN, OffsetCoord.roffsetToCube(OffsetCoord.EVEN, b)));
+        Tests.equalHex("conversion_roundtrip odd-r", a, OffsetCoord.roffsetToCube(OffsetCoord.ODD, OffsetCoord.roffsetFromCube(OffsetCoord.ODD, a)));
+        Tests.equalOffsetcoord("conversion_roundtrip odd-r", b, OffsetCoord.roffsetFromCube(OffsetCoord.ODD, OffsetCoord.roffsetToCube(OffsetCoord.ODD, b)));
+    }
+    static testOffsetFromCube() {
+        Tests.equalOffsetcoord("offset_from_cube even-q", new OffsetCoord(1, 3), OffsetCoord.qoffsetFromCube(OffsetCoord.EVEN, new Hex(1, 2, -3)));
+        Tests.equalOffsetcoord("offset_from_cube odd-q", new OffsetCoord(1, 2), OffsetCoord.qoffsetFromCube(OffsetCoord.ODD, new Hex(1, 2, -3)));
+    }
+    static testOffsetToCube() {
+        Tests.equalHex("offset_to_cube even-", new Hex(1, 2, -3), OffsetCoord.qoffsetToCube(OffsetCoord.EVEN, new OffsetCoord(1, 3)));
+        Tests.equalHex("offset_to_cube odd-q", new Hex(1, 2, -3), OffsetCoord.qoffsetToCube(OffsetCoord.ODD, new OffsetCoord(1, 2)));
+    }
+    static testDoubledRoundtrip() {
+        var a = new Hex(3, 4, -7);
+        var b = new DoubledCoord(1, -3);
+        Tests.equalHex("conversion_roundtrip doubled-q", a, DoubledCoord.qdoubledFromCube(a).qdoubledToCube());
+        Tests.equalDoubledcoord("conversion_roundtrip doubled-q", b, DoubledCoord.qdoubledFromCube(b.qdoubledToCube()));
+        Tests.equalHex("conversion_roundtrip doubled-r", a, DoubledCoord.rdoubledFromCube(a).rdoubledToCube());
+        Tests.equalDoubledcoord("conversion_roundtrip doubled-r", b, DoubledCoord.rdoubledFromCube(b.rdoubledToCube()));
+    }
+    static testDoubledFromCube() {
+        Tests.equalDoubledcoord("doubled_from_cube doubled-q", new DoubledCoord(1, 5), DoubledCoord.qdoubledFromCube(new Hex(1, 2, -3)));
+        Tests.equalDoubledcoord("doubled_from_cube doubled-r", new DoubledCoord(4, 2), DoubledCoord.rdoubledFromCube(new Hex(1, 2, -3)));
+    }
+    static testDoubledToCube() {
+        Tests.equalHex("doubled_to_cube doubled-q", new Hex(1, 2, -3), new DoubledCoord(1, 5).qdoubledToCube());
+        Tests.equalHex("doubled_to_cube doubled-r", new Hex(1, 2, -3), new DoubledCoord(4, 2).rdoubledToCube());
+    }
+    static testAll() {
+        Tests.testHexArithmetic();
+        Tests.testHexDirection();
+        Tests.testHexNeighbor();
+        Tests.testHexDiagonal();
+        Tests.testHexDistance();
+        Tests.testHexRotateRight();
+        Tests.testHexRotateLeft();
+        Tests.testHexRound();
+        Tests.testHexLinedraw();
+        Tests.testLayout();
+        Tests.testOffsetRoundtrip();
+        Tests.testOffsetFromCube();
+        Tests.testOffsetToCube();
+        Tests.testDoubledRoundtrip();
+        Tests.testDoubledFromCube();
+        Tests.testDoubledToCube();
+    }
+}
+// Tests
+function complain(name) { console.log("FAIL", name); }
+Tests.testAll();

package/index.js

@@ -2,28 +2,135 @@ import * as h3 from 'h3-js';
 import OpenAI from 'openai';
 import Gun from 'gun'
 import Ajv2019 from 'ajv/dist/2019.js'
-import { createHash } from "crypto";
 
 class HoloSphere {
     constructor(appname, openaikey = null) {
-        this.appname = appname;
         this.validator = new Ajv2019({ allErrors: false, strict: false });
         this.gun = Gun({
-            peers: ['https://59.src.eco/gun'],
-            axe: false
+            peers: ['http://gun.holons.io', 'https://59.src.eco/gun'],
+            axe: false,
+            // uuid: (content) => { // generate a unique id for each node
+            //     console.log('uuid', content);
+            //     return content;}
         });
 
+        this.gun = this.gun.get(appname)
+
         if (openaikey != null) {
             this.openai = new OpenAI({
                 apiKey: openaikey,
             });
         }
 
+        //this.bot.command('sethex', async (ctx) => { this.setHex(ctx) }) TODO: MOVE HERE FROM SETTINGS
+
+        // this.bot.command('resethex', async (ctx) => {
+        //     let chatID = ctx.message.chat.id;
+        //     let hex = (await this.db.get('settings', chatID)).hex
+        //     this.delete(hex, ctx.message.text.split(' ')[1])
+        // })
+
+        // this.bot.command('get', async (ctx) => {
+        //     const chatID = ctx.message.chat.id;
+        //     const lense = ctx.message.text.split(' ')[1];
+        //     if (!lense) {
+        //         return ctx.reply('Please specify a tag.');
+        //     }
+        //     let hex = (await this.db.get('settings', chatID)).hex
+        //     //let hex = settings.hex
+        //     console.log('hex', hex)
+
+        //     let data = await this.get(ctx, hex, lense)
+
+        // })
+
+        // this.bot.command('gethex', async (ctx) => {
+        //     let settings = await this.db.get('settings', chatID)
+        //     let id = settings.hex ? settings.hex : 'Hex not set, use /sethex'
+        //     ctx.reply(id)
+        // })
+
+        // this.bot.command('compute', async (ctx) => {
+        //     const chatID = ctx.message.chat.id;
+        //     let operation = ctx.message.text.split(' ')[1];
+        //     if (operation != 'sum') {
+        //         ctx.reply('Operation not implemented')
+        //         return
+        //     }
+        //     let lense = ctx.message.text.split(' ')[2]
+        //     if (!lense) {
+        //         ctx.reply('Please specify a lense where to perform the operation ')
+        //         return
+        //     }
+        //     let hex = (await this.db.get('settings', chatID)).hex
+        //     await this.compute(hex, lense, operation)
+
+        //     // let parentInfo = await this.getCellInfo(parent)
+        //     // parentInfo.wisdom[id] = report
+        //     // //update summary
+        //     // let summary = await this.summarize(Object.values(parentInfo.wisdom).join('\n'))
+        //     // parentInfo.summary = summary
+
+        //     // await this.db.put('cell', parentInfo)
+        //     // return parentInfo
+
+        //     // let content = await this.db.getAll(hex+'/tags')
+        // })
+
+
+
+
+        // this.bot.command('cast', async (ctx) => {
+        //     if (!ctx.message.reply_to_message) {
+        //         return ctx.reply('Please reply to a message you want to tag.');
+        //     }
+        //     const tags = ctx.message.text.split(' ').slice(1);
+        //     if (tags.length === 0) {
+        //         return ctx.reply('Please provide at least one tag.');
+        //     }
+
+        //     const messageID = ctx.message.reply_to_message.message_id;
+        //     const chatID = ctx.message.chat.id;
+        //     const messageContent = ctx.message.reply_to_message.text;
+        //     let settings = await this.db.get('settings', chatID)
+        //     let id = settings.hex ? settings.hex : 'Hex not set, use /sethex'
+        //     //create root node for the item
+        //     let node = await this.gun.get(chatID + '/' + messageID).put({ id: chatID + '/' + messageID, content: messageContent })
+        //     for (let tag of tags) {
+        //         await this.gun.get(id).get(tag).set(node)
+        //         this.upcast(id, tag, node)
+        //     }
+        // })
+
+        // this.bot.command('publish', async (ctx) => {
+        //     console.log(ctx.message)
+        //     if (!ctx.message.reply_to_message) {
+        //         return ctx.reply('Please reply to a message you want to tag.');
+        //     }
+        //     const tags = ctx.message.text.split(' ').slice(1);
+        //     if (tags.length === 0) {
+        //         return ctx.reply('Please provide at least one tag.');
+        //     }
+
+        //     const messageID = ctx.message.reply_to_message.message_id;
+        //     const chatID = ctx.message.chat.id;
+        //     const messageContent = ctx.message.reply_to_message.text;
+        //     let settings = await this.db.get('settings', chatID)
+        //     let hex = settings.hex
+
+        //     for (let tag of tags) {
+        //         let node = await this.gun.get(chatID + '/' + messageID).put({ id: chatID + '/' + messageID, content: messageContent })
+        //         await this.put(hex, tag, node)
+        //     }
+
+        //     ctx.reply('Tag published.');
+        // });
+
     }
 
     async setSchema(lense, schema) {
         return new Promise((resolve, reject) => {
-            this.gun.get(this.appname).get(lense).get('schema').put(JSON.stringify(schema), ack => {
+            this.gun.get(lense).get('schema').put(JSON.stringify(schema), ack => {
                 if (ack.err) {
                     resolve(new Error('Failed to add schema: ' + ack.err));
                 } else {
@@ -36,7 +143,7 @@ class HoloSphere {
 
     async getSchema(lense) {
         return new Promise((resolve) => {
-            this.gun.get(this.appname).get(lense).get('schema').once(data => {
+            this.gun.get(lense).get('schema').once(data => {
                 if (data) {
                     let parsed;
                     try {
@@ -71,12 +178,11 @@ class HoloSphere {
     }
 
     async delete(id, tag) {
-        await this.gun.get(this.appname).get(id).get(tag).put(null)
+        await this.gun.get(id).get(tag).put(null)
     }
 
     async put(hex, lense, content) {
         // Retrieve the schema for the lense
-        console.log('HoloSphere: Putting content in lense:', lense, 'at hex:', hex, 'content:', content)
         let schema = await this.getSchema(lense)
         if (schema) {
             // Validate the content against the schema
@@ -93,16 +199,20 @@ class HoloSphere {
         let noderef;
 
         if (content.id) { //use the user-defined id. Important to be able to send updates using put
-            noderef = this.gun.get(this.appname).get(lense).get(content.id).put(payload)
-            this.gun.get(this.appname).get(hex.toString()).get(lense).get(content.id).put(payload)
+            noderef = this.gun.get(lense).get(content.id).put(payload)
+            this.gun.get(hex.toString()).get(lense).get(content.id).put(payload)
         } else { // create a content-addressable reference like IPFS. Note: no updates possible using put
-            const hash = createHash("sha256").update(payload).digest("hex");
-            noderef = this.gun.get(this.appname).get(lense).get(hash).put(payload)
-            this.gun.get(this.appname).get(hex.toString()).get(lense).get(hash).put(payload)
+            //const hash = createHash("sha256").update(payload).digest("hex");
+            const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
+            // const hashHex = Array.from(new Uint8Array(hash))
+            //     .map(byte => byte.toString(16).padStart(2, "0"))
+            //     .join("");
+            noderef = this.gun.get(lense).get(hash).put(payload)
+            this.gun.get(hex.toString()).get(lense).get(hash).put(payload)
         }
 
         // return new Promise((resolve, reject) => {
-        //     this.gun.get(this.appname).get(hex.toString()).get(lense).set(noderef, ack => {
+        //     this.gun.get(hex.toString()).get(lense).set(noderef, ack => {
         //         if (ack.err) {
         //             reject(new Error('Failed to add content: ' + ack.err));
         //         } else {
@@ -127,16 +237,16 @@ class HoloSphere {
         return new Promise(async (resolve, reject) => {
             let output = []
             let counter = 0
-            this.gun.get(this.appname).get(hex.toString()).get(lense).once((data, key) => {
+            this.gun.get(hex.toString()).get(lense).once((data, key) => {
                 if (data) {
                     const maplenght = Object.keys(data).length - 1
                     console.log('Map length:', maplenght)
-                    this.gun.get(this.appname).get(hex.toString()).get(lense).map().once(async (itemdata, key) => {
+                    this.gun.get(hex.toString()).get(lense).map().once(async (itemdata, key) => {
                         counter += 1
                         if (itemdata) {
                             // if (itemdata._["#"]) {
                             //     // If the data is a reference, fetch the actual content
-                            //     itemdata = await this.gun.get(this.appname).get(itemdata._['#']).then();
+                            //     itemdata = await this.gun.get(itemdata._['#']).then();
                             //     console.log("Data :",itemdata)
                             // }
                             var parsed = {}
@@ -151,7 +261,7 @@ class HoloSphere {
                                 let valid = this.validator.validate(schema, parsed);
                                 if (!valid || parsed == null || parsed == undefined) {
                                     console.log('Removing Invalid content:', this.validator.errors);
-                                    this.gun.get(this.appname).get(hex).get(lense).get(key).put(null);
+                                    this.gun.get(hex).get(lense).get(key).put(null);
 
                                 } else {
                                     output.push(parsed);
@@ -208,7 +318,7 @@ class HoloSphere {
         console.log('Content:', content);
         let computed = await this.summarize(content.join('\n'))
         console.log('Computed:', computed)
-        let node = await this.gun.get(this.appname).get(parent + '_summary').put({ id: parent + '_summary', content: computed })
+        let node = await this.gun.get(parent + '_summary').put({ id: parent + '_summary', content: computed })
 
         this.put(parent, lense, node);
         this.compute(parent, lense, operation)
@@ -218,10 +328,10 @@ class HoloSphere {
         let entities = {};
 
         // Get list out of Gun
-        this.gun.get(this.appname).get(hex).get(lense).map().once((data, key) => {
+        this.gun.get(hex).get(lense).map().once((data, key) => {
             //entities = data;
             //const id = Object.keys(entities)[0] // since this would be in object form, you can manipulate it as you would like. 
-            this.gun.get(this.appname).get(hex).get(lense).put({ [key]: null })
+            this.gun.get(hex).get(lense).put({ [key]: null })
         })
     }
 
@@ -260,15 +370,15 @@ class HoloSphere {
 
     async upcast(hex, lense, content) {
         let res = h3.getResolution(hex)
-    
-        if (res == 0)
-            return content
+
 
         console.log('Upcasting ', hex, lense, content)
         let parent = h3.cellToParent(hex, res - 1)
         await this.put(parent, lense, content)
-        
-        return this.upcast(parent, lense, content)
+        if (res == 0)
+            return content
+        else
+            return this.upcast(parent, lense, content)
     }
 
 
@@ -312,6 +422,62 @@ class HoloSphere {
         }
         return list
     }
+
+    subscribe(hex, lense, callback) {
+        this.gun.get(hex).get(lense).map().on((data, key) => {
+            callback(data, key)
+        })
+    }
+
+    // VOTING SYSTEM
+
+     getFinalVote(userId, topic, votes, visited = new Set()) {
+  if (visited.has(userId)) {
+    return null; // Avoid circular delegations
+  }
+  visited.add(userId);
+
+  const delegation = users[userId].delegations[topic];
+  if (delegation && votes[delegation] === undefined) {
+    return getFinalVote(delegation, topic, votes, visited); // Follow delegation
+  }
+
+  return votes[userId] !== undefined ? votes[userId] : null; // Return direct vote or null
+}
+
+ aggregateVotes(hexId, topic) {
+  const votes = hexagonVotes[hexId][topic];
+  const aggregatedVotes = {};
+
+  Object.keys(votes).forEach(userId => {
+    const finalVote = getFinalVote(userId, topic, votes);
+    if (finalVote !== null) {
+      aggregatedVotes[finalVote] = (aggregatedVotes[finalVote] || 0) + 1;
+    }
+  });
+
+  return aggregatedVotes;
+}
+
+async delegateVote(userId, topic, delegateTo) {
+        const response = await fetch('/delegate', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ userId, topic, delegateTo })
+        });
+        alert(await response.text());
+    }
+
+    async vote(userId, hexId, topic, vote) {
+        const response = await fetch('/vote', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ userId, hexId, topic, vote })
+        });
+        alert(await response.text());
+    }
+
+
 }
 
 export default HoloSphere;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Holonic Geospatial Communication Infrastructure based on h3.js and gun.js",
   "main": "index.js",
   "type": "module",
@@ -11,7 +11,7 @@
   "license": "GPL-3.0-or-later",
   "dependencies": {
     "ajv": "^8.12.0",
-    "gun": "^0.2020.1239",
+    "gun": "^0.2020.1240",
     "h3-js": "^4.1.0",
     "openai": "^4.29.2"
   }