work on notifications and sql queries

Author: thiscaspar

packages/core-dojo/src/DojoEngine.ts

@@ -21,7 +21,7 @@ import DojoSqlPixelStore from "./DojoSqlPixelStore.ts"
 import { DojoWallet } from "./DojoWallet.ts"
 import { type DojoConfig, ENGINE_ID } from "./types.ts"
 import { DojoExecutor } from "./DojoExecutor.ts"
-import { DojoAlertStore } from "./DojoAlertStore.ts"
+import { DojoNotificationStore } from "./DojoNotificationStore.ts"
 
 export class DojoEngine implements Engine {
     id: Engines = ENGINE_ID
@@ -57,7 +57,7 @@ export class DojoEngine implements Engine {
 
             this.core.queue = await DojoQueueStore.getInstance(this.config.toriiUrl, this.dojoSetup)
 
-            this.core.alerts = await DojoAlertStore.getInstance(this.core)
+            this.core.notification = await DojoNotificationStore.getInstance(this.core)
         } catch (error) {
             console.error("Dojo init error:", error)
         }
@@ -75,7 +75,7 @@ export class DojoEngine implements Engine {
 
     async executeQueueItem(item: QueueItem): Promise<boolean> {
         const dojoCall = {
-            contractAddress: "0x5386eb3153d91bd740a4e17933f26056ce10faddf9a06f56a2c23c0c4794cb5", // TODO properly configure pixelaw_actions contract,
+            contractAddress: "0x1f455be12a750b7228e5626e1efd6bcee4849f24e98bb098371d6e8f773f3", // TODO properly configure pixelaw_actions contract,
             entrypoint: "process_queue",
             calldata: [
                 item.id,

packages/core-dojo/src/DojoAlertStore.ts …s/core-dojo/src/DojoNotificationStore.tspackages/core-dojo/src/DojoAlertStore.ts renamed to packages/core-dojo/src/DojoNotificationStore.ts packages/core-dojo/src/DojoAlertStore.ts renamed to packages/core-dojo/src/DojoNotificationStore.ts

@@ -1,15 +1,16 @@
 import { KeysClause, type SDK } from "@dojoengine/sdk"
 import { queryTorii } from "@dojoengine/sdk/sql"
 import {
-    type AlertStore,
-    type Alert,
+    type NotificationStore,
+    type Notification,
     QueueStore,
-    type AlertStoreEvents,
+    type NotificationStoreEvents,
     type Bounds,
     MAX_DIMENSION,
     areBoundsEqual,
     type PixelawCore,
     type Coordinate,
+    type Position,
 } from "@pixelaw/core"
 import mitt from "mitt"
 import type { DojoStuff } from "./DojoEngine.init.ts"
@@ -19,15 +20,15 @@ import { getQueryBounds } from "./utils/querybuilder.ts"
 import type { DojoEngine } from "./DojoEngine.ts"
 import { convertFullHexString } from "./utils/utils.ts"
 
-type State = { [key: string]: Alert | undefined }
+type State = { [key: string]: Notification | undefined }
 
 const QUERY_RADIUS = 20
 
-export class DojoAlertStore implements AlertStore {
-    public readonly eventEmitter = mitt<AlertStoreEvents>()
+export class DojoNotificationStore implements NotificationStore {
+    public readonly eventEmitter = mitt<NotificationStoreEvents>()
     private dojoStuff
     private sdk: SDK<SchemaType>
-    private static instance: DojoAlertStore
+    private static instance: DojoNotificationStore
     private isSubscribed = false
     private cacheUpdated: number = Date.now()
     private state: State = {}
@@ -43,34 +44,40 @@ export class DojoAlertStore implements AlertStore {
     }
 
     // Singleton factory
-    public static async getInstance(core: PixelawCore): Promise<DojoAlertStore> {
-        if (!DojoAlertStore.instance) {
-            DojoAlertStore.instance = new DojoAlertStore(core)
+    public static async getInstance(core: PixelawCore): Promise<DojoNotificationStore> {
+        if (!DojoNotificationStore.instance) {
+            DojoNotificationStore.instance = new DojoNotificationStore(core)
 
-            await DojoAlertStore.instance.subscribe()
-            await DojoAlertStore.instance.initialize()
+            await DojoNotificationStore.instance.subscribe()
+            await DojoNotificationStore.instance.initialize()
         }
-        return DojoAlertStore.instance
+        return DojoNotificationStore.instance
     }
 
     private async initialize() {
         try {
+            // TODO Notifications should be filtered by wallet address
+            // const wallet = this.core.wallet as DojoWallet
+
             const items = await queryTorii(
                 this.toriiUrl,
-                createSqlQueryByRadius(this.core.getCenter(), QUERY_RADIUS),
+                createSqlQueryByRadius(
+                    this.core.getCenter(),
+                    QUERY_RADIUS,
+                    this.core.lastNotification /*,  wallet.getAccount()*/,
+                ),
                 (rows: any[]) => {
                     return rows.map((item) => {
                         // const item = JSON.parse(str.d)
                         return {
                             ...item,
-                            message: convertFullHexString(item.message),
-                            timestamp: Number.parseInt(item.timestamp, 16),
-                        } as Alert
+                            message: convertFullHexString(item.text),
+                        } as Notification
                     })
                 },
             )
             for (const item of items) {
-                this.setAlert(item.id, item)
+                // this.setNotification(item.id, item)
                 this.eventEmitter.emit("added", item)
             }
         } catch (e) {
@@ -82,25 +89,33 @@ export class DojoAlertStore implements AlertStore {
         if (this.isSubscribed) return
         try {
             const subscription = this.sdk.client.onEventMessageUpdated(
-                [KeysClause(["pixelaw-Alert"], [undefined], "VariableLen").build() as unknown as EntityKeysClause],
+                [
+                    KeysClause(
+                        ["pixelaw-Notification"],
+                        [undefined],
+                        "VariableLen",
+                    ).build() as unknown as EntityKeysClause,
+                ],
                 (id, data) => {
                     if (id === "0x0") return
                     try {
-                        const item = data["pixelaw-Alert"]
-                        const alert: Alert = {
-                            caller: item.caller.value,
-                            player: item.player.value,
+                        const item = data["pixelaw-Notification"]
+                        console.log(item)
+                        const notification: Notification = {
+                            from: item.from.value.option === "None" ? null : item.from.value.value.value,
+                            to: item.to.value.option === "None" ? null : item.to.value.value.value,
+                            color: item.color.value,
+                            app: item.app.value, // TODO
                             position: {
                                 x: item.position.value.x.value,
                                 y: item.position.value.y.value,
                             },
-                            message: convertFullHexString(item.message.value),
-                            timestamp: Number.parseInt(item.timestamp.value, 16),
+                            text: convertFullHexString(item.text.value),
                         }
-                        // console.log("alert", alert)
-                        // TODO decide if we store the Alert or not
-                        // this.setAlert(item.id.value, alert)
-                        this.core.events.emit("alert", alert)
+                        // console.log("notification", notification)
+                        // TODO decide if we store the Notification or not
+                        // this.setNotification(item.id.value, notification)
+                        this.core.events.emit("notification", notification)
                     } catch (e) {
                         console.error(e)
                     }
@@ -120,11 +135,11 @@ export class DojoAlertStore implements AlertStore {
         }
     }
 
-    public setAlert(key: string, Alert: Alert): void {
-        this.state[key] = Alert
+    public setNotification(key: string, Notification: Notification): void {
+        this.state[key] = Notification
     }
 
-    getAll(): Alert[] {
+    getAll(): Notification[] {
         return this.dojoStuff!.apps
     }
 
@@ -136,29 +151,33 @@ export class DojoAlertStore implements AlertStore {
         }
     }
 
-    getLastForPosition(position: Position): Alert[] {
+    getLastForPosition(position: Position): Notification[] {
         return []
     }
 }
-export function createSqlQueryByRadius(center: Coordinate, radius: number) {
+export function createSqlQueryByRadius(center: Coordinate, radius: number, lastNotification: number, address: string) {
+    console.log("add", address)
     let result = `SELECT
-                      caller, player, message, "position.x" , "position.y", timestamp
-                  FROM "pixelaw-Alert"
+                      "from", "to", "text", "position.x" , "position.y", "color"
+                  FROM "pixelaw-Notification"
                   WHERE (("position.x" - ${center[0]}) * ("position.x" - ${center[0]}) + ("position.y" -  ${center[1]}) * ("position.y" -  ${center[1]})) <= (${radius} * ${radius})
     `
 
     result += ";"
     return result
 }
+/*
+
 export function createSqlQuery(bounds: Bounds) {
     const [[left, top], [right, bottom]] = bounds
 
     let result = `SELECT
                       json_array(A.caller, A.player, ltrim(substr(A.message, 4), '0'), (A.x << 16) | A.y, A.timestamp) as d
-                  FROM "pixelaw-Alert" as A
+                  FROM "pixelaw-Notification" as A
                   WHERE (A.x >= ${left} AND A.y >= ${top} AND A.x <= ${right} AND A.y <= ${bottom} )
                   `
 
     result += ";"
     return result
 }
+*/

packages/core-dojo/src/DojoSqlPixelStore.ts

@@ -69,7 +69,6 @@ class DojoSqlPixelStore implements PixelStore {
             DojoSqlPixelStore.instance.worker.onmessage = DojoSqlPixelStore.instance.handleRefreshWorker.bind(
                 DojoSqlPixelStore.instance,
             )
-            console.log("subbing")
             DojoSqlPixelStore.instance.subscribe()
         }
         return DojoSqlPixelStore.instance
@@ -102,11 +101,11 @@ class DojoSqlPixelStore implements PixelStore {
                                 text: convertFullHexString(p.text.value),
                                 timestamp: p.timestamp.value,
                                 app,
-                                x: p.x.value,
-                                y: p.y.value,
+                                x: p.position.value.x.value,
+                                y: p.position.value.y.value,
                             }
 
-                            const key = `${p?.x.value}_${p?.y.value}`
+                            const key = `${pixel.x}_${pixel.y}`
                             this.idLookupTable[id] = key
                             this.setPixel(key, pixel)
                         }
@@ -217,11 +216,11 @@ export function createSqlQuery(bounds: Bounds) {
     const [[left, top], [right, bottom]] = bounds
 
     let result = `SELECT
-                      json_array(P.color, ltrim(substr(P.text, 32), '0'), ltrim(substr(P.action, 3), '0'), (P.x << 16) | P.y, ltrim(substr(A.name, 4), '0' )) as d
+                      json_array(P.color, ltrim(substr(P.text, 32), '0'), ltrim(substr(P.action, 3), '0'), (P."position.x" << 16) | P."position.y", ltrim(substr(A.name, 4), '0' )) as d
                   FROM "pixelaw-Pixel" as P
                            INNER JOIN "Pixelaw-App" as A
                                       ON P.app = A.system
-                  WHERE (P.x >= ${left} AND P.y >= ${top} AND P.x <= ${right} AND P.y <= ${bottom} )
+                  WHERE (P."position.x" >= ${left} AND P."position.y" >= ${top} AND P."position.x" <= ${right} AND P."position.y" <= ${bottom} )
                   `
 
     result += ";"