@wodzik/cubecore 0.1.0

package/bluetooth/gyro.js

@@ -0,0 +1,46 @@
+/**
+ * Gyroscope → renderer orientation. A smart cube reports its rotation as a
+ * quaternion in its own axes; the renderer (`CubeRenderer.setOrientation`)
+ * wants one in ours (x right, y up, z towards you) where identity = the cube
+ * as drawn. `calibrate` (or the first reading) says "the cube is held as
+ * shown right now".
+ */
+export const IDENTITY = { x: 0, y: 0, z: 0, w: 1 };
+export function multiply(a, b) {
+    return {
+        w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
+        x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+        y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+        z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    };
+}
+export const conjugate = (q) => ({ x: -q.x, y: -q.y, z: -q.z, w: q.w });
+export function normalize(q) {
+    const l = Math.hypot(q.x, q.y, q.z, q.w) || 1;
+    return { x: q.x / l, y: q.y / l, z: q.z / l, w: q.w / l };
+}
+export const GAN_AXES = (q) => ({ x: q.x, y: q.z, z: -q.y, w: q.w });
+export class GyroCalibrator {
+    axes;
+    basis = null;
+    last = null;
+    constructor(axes = GAN_AXES) {
+        this.axes = axes;
+    }
+    /** A raw reading → the orientation to show (identity at calibration). The first reading calibrates. */
+    orientation(raw) {
+        const q = normalize(this.axes(raw));
+        this.last = q;
+        this.basis ??= conjugate(q);
+        return normalize(multiply(this.basis, q));
+    }
+    /** "Held as shown now": the latest reading becomes identity. */
+    calibrate() {
+        if (this.last)
+            this.basis = conjugate(this.last);
+    }
+    reset() {
+        this.basis = null;
+        this.last = null;
+    }
+}

package/bluetooth/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./clock.js";
+export * from "./gyro.js";
+export * from "./session.js";
+export * from "./simulated.js";
+export * from "./cubeSkins.js";

package/bluetooth/index.js

@@ -0,0 +1,5 @@
+export * from "./clock.js";
+export * from "./gyro.js";
+export * from "./session.js";
+export * from "./simulated.js";
+export * from "./cubeSkins.js";

package/bluetooth/session.d.ts

@@ -0,0 +1,140 @@
+/**
+ * SmartCubeSession — a connected smart cube as cubecore sees it. Wraps
+ * smartcube-web-bluetooth (GAN, MoYu, QiYi, GoCube, Giiker…) and turns its
+ * events into cubecore values:
+ *
+ *   move        each face turn as a Move, with a trustworthy time (see clock.ts)
+ *               and whether it arrived late; plus the state after it
+ *   state       the tracked cube state — also after a FACELETS report that
+ *               disagrees with it (a missed move: the cube knows best)
+ *   orientation gyro, calibrated, ready for CubeRenderer.setOrientation
+ *   battery, hardware, disconnect
+ *
+ * Feed the moves to MoveCollapser (written log), OrientationTracker,
+ * MethodTracker or a timeline recording as needed.
+ */
+import { type Move, type State } from "../core/index.js";
+import type { ConnectSmartCubeOptions, SmartCubeCapabilities, SmartCubeCommand, SmartCubeEvent } from "./vendor/smartcube-web-bluetooth/index.js";
+import type { Skin } from "../skin/index.js";
+import { type AxisMap, type Quat } from "./gyro.js";
+/** What the session needs from a connection — smartcube-web-bluetooth's, or a SimulatedCube. */
+export interface CubeConnection {
+    readonly deviceName: string;
+    readonly deviceMAC: string;
+    readonly protocol: {
+        id: string;
+        name: string;
+    };
+    readonly capabilities: SmartCubeCapabilities;
+    events$: {
+        subscribe(next: (e: SmartCubeEvent) => void): {
+            unsubscribe(): void;
+        };
+    };
+    sendCommand(command: SmartCubeCommand): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export interface CubeMoveEvent {
+    move: Move;
+    /** When it happened, on the page's clock (performance.now()). */
+    time: number;
+    /** The cube's own timestamp, if it sends one. */
+    cubeTime: number | null;
+    /** Arrived much later than it happened (a backgrounded tab, a resent packet). */
+    late: boolean;
+    /** The state after this move. */
+    state: State;
+}
+export interface HardwareInfo {
+    name?: string;
+    softwareVersion?: string;
+    hardwareVersion?: string;
+    gyroSupported?: boolean;
+}
+interface Events {
+    move: CubeMoveEvent;
+    state: {
+        state: State;
+        reason: "move" | "facelets" | "reset";
+    };
+    orientation: Quat;
+    battery: number;
+    hardware: HardwareInfo;
+    disconnect: undefined;
+    /** The cube's own state that counts as solved changed (see `base`) — keep it to pass back next time. */
+    base: State | null;
+}
+export interface SessionOptions {
+    /** A move is `late` when it arrives this much after it happened. Default 1000 ms. */
+    lateMs?: number;
+    /** Gyro axes of this cube (default: GAN). */
+    axes?: AxisMap;
+    /**
+     * For a cube that can't reset its own state (QiYi…): the state of it that
+     * counts as solved, kept from an earlier connection (the `base` event) —
+     * or a function picking it by the cube (name / MAC).
+     */
+    base?: State | null | ((info: {
+        name: string;
+        mac: string | null;
+    }) => State | null);
+}
+export declare class SmartCubeSession {
+    private readonly connection;
+    private listeners;
+    private _state;
+    private _battery;
+    private _hardware;
+    private readonly clock;
+    private readonly gyro;
+    private readonly subscription;
+    private readonly lateMs;
+    private connected;
+    /** Ask the browser for a cube and connect (needs a user gesture; Chrome / Edge / Bluefy). */
+    static connect(options?: ConnectSmartCubeOptions, session?: SessionOptions): Promise<SmartCubeSession>;
+    constructor(connection: CubeConnection, options?: SessionOptions);
+    get info(): {
+        name: string;
+        mac: string;
+        protocol: {
+            id: string;
+            name: string;
+        };
+        capabilities: SmartCubeCapabilities;
+    };
+    get state(): State;
+    get battery(): number | null;
+    get hardware(): HardwareInfo;
+    /** A skin that suits this cube (see cubeSkins.ts; refines once the hardware name arrives). */
+    get suggestedSkin(): Skin;
+    get isConnected(): boolean;
+    on<K extends keyof Events>(type: K, listener: (e: Events[K]) => void): () => void;
+    /** "Held as shown now" for the gyro. */
+    calibrate(): void;
+    /**
+     * Tell the session (and the cube, if it can) that the cube is solved now.
+     * Cubes that can't reset their own state (QiYi, …) keep reporting it: the
+     * next facelets report becomes the reference ("solved" as marked) and
+     * later reports are read relative to it — so they don't undo the mark.
+     */
+    markSolved(): void;
+    /**
+     * The cube's own state that counts as solved (a cube that can't reset,
+     * after "mark solved"), or null: its reports are its state as they are.
+     */
+    get base(): State | null;
+    /** Set the reference from an earlier connection (see `base`); the state is read again. */
+    setBase(base: State | null): void;
+    requestState(): void;
+    requestBattery(): void;
+    disconnect(): Promise<void>;
+    private send;
+    private emit;
+    /** The cube's own state that counts as solved (after "mark solved" on a cube that didn't reset), or null. */
+    private _base;
+    /** "Mark solved" was pressed: the next facelets report sets `base`. */
+    private rebase;
+    private setState;
+    private onEvent;
+}
+export {};

package/bluetooth/session.js

@@ -0,0 +1,201 @@
+/**
+ * SmartCubeSession — a connected smart cube as cubecore sees it. Wraps
+ * smartcube-web-bluetooth (GAN, MoYu, QiYi, GoCube, Giiker…) and turns its
+ * events into cubecore values:
+ *
+ *   move        each face turn as a Move, with a trustworthy time (see clock.ts)
+ *               and whether it arrived late; plus the state after it
+ *   state       the tracked cube state — also after a FACELETS report that
+ *               disagrees with it (a missed move: the cube knows best)
+ *   orientation gyro, calibrated, ready for CubeRenderer.setOrientation
+ *   battery, hardware, disconnect
+ *
+ * Feed the moves to MoveCollapser (written log), OrientationTracker,
+ * MethodTracker or a timeline recording as needed.
+ */
+import { applyMove, parseAlg, relativeState, solvedState, stateFromFacelets, statesEqual } from "../core/index.js";
+import { ClockSync } from "./clock.js";
+import { skinForCube } from "./cubeSkins.js";
+import { GAN_AXES, GyroCalibrator } from "./gyro.js";
+export class SmartCubeSession {
+    connection;
+    listeners = new Map();
+    _state = solvedState();
+    _battery = null;
+    _hardware = {};
+    clock = new ClockSync();
+    gyro;
+    subscription;
+    lateMs;
+    connected = true;
+    /** Ask the browser for a cube and connect (needs a user gesture; Chrome / Edge / Bluefy). */
+    static async connect(options, session) {
+        const { connectSmartCube } = await import("./vendor/smartcube-web-bluetooth/index.js");
+        return new SmartCubeSession(await connectSmartCube(options), session);
+    }
+    constructor(connection, options = {}) {
+        this.connection = connection;
+        this.lateMs = options.lateMs ?? 1000;
+        this.gyro = new GyroCalibrator(options.axes ?? GAN_AXES);
+        const base = typeof options.base === "function" ? options.base({ name: connection.deviceName, mac: connection.deviceMAC ?? null }) : options.base;
+        this._base = base ?? null;
+        this.subscription = connection.events$.subscribe((e) => this.onEvent(e));
+        if (connection.capabilities.facelets)
+            this.send({ type: "REQUEST_FACELETS" });
+        if (connection.capabilities.battery)
+            this.send({ type: "REQUEST_BATTERY" });
+        if (connection.capabilities.hardware)
+            this.send({ type: "REQUEST_HARDWARE" });
+    }
+    get info() {
+        const c = this.connection;
+        return { name: c.deviceName, mac: c.deviceMAC, protocol: c.protocol, capabilities: c.capabilities };
+    }
+    get state() {
+        return this._state;
+    }
+    get battery() {
+        return this._battery;
+    }
+    get hardware() {
+        return this._hardware;
+    }
+    /** A skin that suits this cube (see cubeSkins.ts; refines once the hardware name arrives). */
+    get suggestedSkin() {
+        return skinForCube({ protocol: this.connection.protocol, name: this.connection.deviceName, hardwareName: this._hardware.name });
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    on(type, listener) {
+        let set = this.listeners.get(type);
+        if (!set)
+            this.listeners.set(type, (set = new Set()));
+        set.add(listener);
+        return () => set.delete(listener);
+    }
+    /** "Held as shown now" for the gyro. */
+    calibrate() {
+        this.gyro.calibrate();
+    }
+    /**
+     * Tell the session (and the cube, if it can) that the cube is solved now.
+     * Cubes that can't reset their own state (QiYi, …) keep reporting it: the
+     * next facelets report becomes the reference ("solved" as marked) and
+     * later reports are read relative to it — so they don't undo the mark.
+     */
+    markSolved() {
+        if (this.connection.capabilities.reset)
+            this.send({ type: "REQUEST_RESET" });
+        this.setState(solvedState(), "reset");
+        if (this.connection.capabilities.facelets) {
+            this.rebase = true;
+            this.send({ type: "REQUEST_FACELETS" });
+        }
+    }
+    /**
+     * The cube's own state that counts as solved (a cube that can't reset,
+     * after "mark solved"), or null: its reports are its state as they are.
+     */
+    get base() {
+        return this._base;
+    }
+    /** Set the reference from an earlier connection (see `base`); the state is read again. */
+    setBase(base) {
+        this._base = base;
+        this.rebase = false;
+        if (this.connection.capabilities.facelets)
+            this.send({ type: "REQUEST_FACELETS" });
+    }
+    requestState() {
+        this.send({ type: "REQUEST_FACELETS" });
+    }
+    requestBattery() {
+        this.send({ type: "REQUEST_BATTERY" });
+    }
+    async disconnect() {
+        this.subscription.unsubscribe();
+        await this.connection.disconnect();
+        this.onEvent({ type: "DISCONNECT", timestamp: performance.now() });
+    }
+    send(command) {
+        this.connection.sendCommand(command).catch(() => undefined);
+    }
+    emit(type, e) {
+        for (const l of this.listeners.get(type) ?? [])
+            l(e);
+    }
+    /** The cube's own state that counts as solved (after "mark solved" on a cube that didn't reset), or null. */
+    _base = null;
+    /** "Mark solved" was pressed: the next facelets report sets `base`. */
+    rebase = false;
+    setState(state, reason) {
+        this._state = state;
+        this.emit("state", { state, reason });
+    }
+    onEvent(e) {
+        switch (e.type) {
+            case "MOVE": {
+                const [move] = parseAlg(e.move.replace(/’/g, "'"));
+                if (!move)
+                    return;
+                const arrived = e.localTimestamp ?? e.timestamp;
+                let time = arrived;
+                if (e.cubeTimestamp !== null) {
+                    this.clock.observe(e.cubeTimestamp, e.localTimestamp);
+                    time = this.clock.toLocal(e.cubeTimestamp) ?? arrived;
+                }
+                const state = applyMove(this._state, move);
+                this._state = state;
+                this.emit("move", { move, time, cubeTime: e.cubeTimestamp, late: e.timestamp - time > this.lateMs, state });
+                this.emit("state", { state, reason: "move" });
+                break;
+            }
+            case "FACELETS": {
+                const reported = stateFromFacelets(e.facelets);
+                if (!reported)
+                    return;
+                if (this.rebase) {
+                    // First report after "mark solved": the cube's own state then (moves since the mark taken off) is the new "solved".
+                    const base = baseOf(reported, this._state);
+                    // A cube that did reset reports solved: no reference to keep.
+                    this._base = statesEqual(base, solvedState()) ? null : base;
+                    this.rebase = false;
+                    this.emit("base", this._base);
+                    return;
+                }
+                const s = this._base ? relativeState(reported, this._base) : reported;
+                if (!statesEqual(s, this._state))
+                    this.setState(s, "facelets");
+                break;
+            }
+            case "GYRO":
+                this.emit("orientation", this.gyro.orientation(e.quaternion));
+                break;
+            case "BATTERY":
+                this._battery = e.batteryLevel;
+                this.emit("battery", e.batteryLevel);
+                break;
+            case "HARDWARE":
+                this._hardware = { name: e.hardwareName, softwareVersion: e.softwareVersion, hardwareVersion: e.hardwareVersion, gyroSupported: e.gyroSupported };
+                this.emit("hardware", this._hardware);
+                break;
+            case "DISCONNECT":
+                if (!this.connected)
+                    return;
+                this.connected = false;
+                this.subscription.unsubscribe();
+                this.emit("disconnect", undefined);
+                break;
+        }
+    }
+}
+/**
+ * The cube's own state at the mark: `reported` is it with the moves since
+ * (`sinceMark`, a state from solved) done — so base[x] = reported[inverse(sinceMark)[x]].
+ */
+function baseOf(reported, sinceMark) {
+    const inverse = new Uint8Array(sinceMark.length);
+    sinceMark.forEach((v, i) => (inverse[v] = i));
+    return Uint8Array.from(inverse, (_, x) => reported[inverse[x]]);
+}

package/bluetooth/simulated.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A pretend smart cube with the same events as a real one — for tests,
+ * demos and building an app without a cube at hand. `new
+ * SmartCubeSession(new SimulatedCube())` behaves like a connected cube.
+ */
+import { type Move, type State } from "../core/index.js";
+import type { SmartCubeCommand, SmartCubeEvent } from "./vendor/smartcube-web-bluetooth/index.js";
+import type { CubeConnection } from "./session.js";
+import type { Quat } from "./gyro.js";
+export declare class SimulatedCube implements CubeConnection {
+    readonly deviceName = "Simulated cube";
+    readonly deviceMAC = "00:00:00:00:00:00";
+    readonly protocol: {
+        id: string;
+        name: string;
+    };
+    readonly capabilities: {
+        gyroscope: boolean;
+        battery: boolean;
+        facelets: boolean;
+        hardware: boolean;
+        reset: boolean;
+    };
+    /** Also report the whole state after every move (as QiYi cubes do). */
+    private readonly faceletsOnMove;
+    private subscribers;
+    private state;
+    private cubeClock;
+    /** Simulated Bluetooth latency added to local arrival times (ms). */
+    latency: number;
+    /** `canReset: false` + `faceletsOnMove: true` behave like a QiYi cube. */
+    constructor(options?: {
+        canReset?: boolean;
+        faceletsOnMove?: boolean;
+    });
+    readonly events$: {
+        subscribe: (next: (e: SmartCubeEvent) => void) => {
+            unsubscribe: () => boolean;
+        };
+    };
+    /** Turn the cube. `delayMs` = how late the notification is (e.g. a backgrounded tab); `dropLocalTime` = a resent move. */
+    turn(moves: string | Move, options?: {
+        delayMs?: number;
+        dropLocalTime?: boolean;
+    }): void;
+    tilt(quaternion: Quat): void;
+    /** Change the cube behind the session's back (e.g. a missed move); it only notices on a facelets report. */
+    setStateSilently(state: State): void;
+    sendCommand(command: SmartCubeCommand): Promise<void>;
+    disconnect(): Promise<void>;
+    private emit;
+}

package/bluetooth/simulated.js

@@ -0,0 +1,80 @@
+/**
+ * A pretend smart cube with the same events as a real one — for tests,
+ * demos and building an app without a cube at hand. `new
+ * SmartCubeSession(new SimulatedCube())` behaves like a connected cube.
+ */
+import { applyMove, faceletsOf, formatMove, parseAlg, solvedState } from "../core/index.js";
+export class SimulatedCube {
+    deviceName = "Simulated cube";
+    deviceMAC = "00:00:00:00:00:00";
+    protocol = { id: "simulated", name: "Simulated" };
+    capabilities;
+    /** Also report the whole state after every move (as QiYi cubes do). */
+    faceletsOnMove;
+    subscribers = new Set();
+    state = solvedState();
+    cubeClock = 0;
+    /** Simulated Bluetooth latency added to local arrival times (ms). */
+    latency = 20;
+    /** `canReset: false` + `faceletsOnMove: true` behave like a QiYi cube. */
+    constructor(options = {}) {
+        this.capabilities = { gyroscope: true, battery: true, facelets: true, hardware: true, reset: options.canReset ?? true };
+        this.faceletsOnMove = options.faceletsOnMove ?? false;
+    }
+    events$ = {
+        subscribe: (next) => {
+            this.subscribers.add(next);
+            return { unsubscribe: () => this.subscribers.delete(next) };
+        },
+    };
+    /** Turn the cube. `delayMs` = how late the notification is (e.g. a backgrounded tab); `dropLocalTime` = a resent move. */
+    turn(moves, options = {}) {
+        for (const m of typeof moves === "string" ? parseAlg(moves) : [moves]) {
+            if (!"URFDLB".includes(m.family))
+                throw new Error("A smart cube only turns faces");
+            const quarters = m.amount === 2 ? [{ ...m, amount: 1 }, { ...m, amount: 1 }] : [m];
+            for (const q of quarters) {
+                this.state = applyMove(this.state, q);
+                const happened = performance.now();
+                this.cubeClock = Math.round(happened) + 100_000; // any epoch: only differences matter
+                const arrived = happened + this.latency + (options.delayMs ?? 0);
+                this.emit({
+                    type: "MOVE",
+                    timestamp: arrived,
+                    face: "URFDLB".indexOf(q.family),
+                    direction: q.amount === -1 ? 1 : 0,
+                    move: formatMove(q),
+                    localTimestamp: options.dropLocalTime ? null : arrived,
+                    cubeTimestamp: this.cubeClock,
+                });
+                if (this.faceletsOnMove)
+                    this.emit({ type: "FACELETS", timestamp: arrived, facelets: faceletsOf(this.state) });
+            }
+        }
+    }
+    tilt(quaternion) {
+        this.emit({ type: "GYRO", timestamp: performance.now(), quaternion });
+    }
+    /** Change the cube behind the session's back (e.g. a missed move); it only notices on a facelets report. */
+    setStateSilently(state) {
+        this.state = new Uint8Array(state);
+    }
+    async sendCommand(command) {
+        const timestamp = performance.now();
+        if (command.type === "REQUEST_FACELETS")
+            this.emit({ type: "FACELETS", timestamp, facelets: faceletsOf(this.state) });
+        if (command.type === "REQUEST_BATTERY")
+            this.emit({ type: "BATTERY", timestamp, batteryLevel: 87 });
+        if (command.type === "REQUEST_HARDWARE")
+            this.emit({ type: "HARDWARE", timestamp, hardwareName: "Simulated", gyroSupported: true });
+        if (command.type === "REQUEST_RESET" && this.capabilities.reset)
+            this.state = solvedState();
+    }
+    async disconnect() {
+        this.emit({ type: "DISCONNECT", timestamp: performance.now() });
+    }
+    emit(e) {
+        for (const s of [...this.subscribers])
+            s(e);
+    }
+}

package/bluetooth/vendor/smartcube-web-bluetooth/gan-cube-definitions.d.ts

@@ -0,0 +1,38 @@
+/** LZ-compressed key blobs for GAN gen1 `deriveKey`. */
+export declare const GAN_GEN1_COMPRESSED_KEYS: readonly ["NoRgnAHANATADDWJYwMxQOxiiEcfYgSK6Hpr4TYCs0IG1OEAbDszALpA", "NoNg7ANATFIQnARmogLBRUCs0oAYN8U5J45EQBmFADg0oJAOSlUQF0g", "NoRgNATGBs1gLABgQTjCeBWSUDsYBmKbCeMADjNnXxHIoIF0g", "NoRg7ANAzBCsAMEAsioxBEIAc0Cc0ATJkgSIYhXIjhMQGxgC6QA", "NoVgNAjAHGBMYDYCcdJgCwTFBkYVgAY9JpJYUsYBmAXSA", "NoRgNAbAHGAsAMkwgMyzClH0LFcArHnAJzIqIBMGWEAukA"];
+/** GAN gen1 primary GATT service (356i “API v1”). */
+export declare const GAN_GEN1_PRIMARY_SERVICE = "0000fff0-0000-1000-8000-00805f9b34fb";
+/** Standard Device Information service (gen1 key derivation). */
+export declare const GAN_GEN1_DEVICE_INFO_SERVICE = "0000180a-0000-1000-8000-00805f9b34fb";
+export declare const GAN_GEN1_CHR_FIRMWARE = "00002a28-0000-1000-8000-00805f9b34fb";
+export declare const GAN_GEN1_CHR_HARDWARE = "00002a23-0000-1000-8000-00805f9b34fb";
+export declare const GAN_GEN1_CHR_STATE = "0000fff5-0000-1000-8000-00805f9b34fb";
+export declare const GAN_GEN1_CHR_MOVES = "0000fff6-0000-1000-8000-00805f9b34fb";
+export declare const GAN_GEN1_CHR_GYRO_NOTIFY = "0000fff4-0000-1000-8000-00805f9b34fb";
+export declare const GAN_GEN1_CHR_BATTERY = "0000fff7-0000-1000-8000-00805f9b34fb";
+export declare const GAN_GEN1_CHR_FACELETS = "0000fff2-0000-1000-8000-00805f9b34fb";
+/** GAN Gen2 protocol BLE service */
+export declare const GAN_GEN2_SERVICE = "6e400001-b5a3-f393-e0a9-e50e24dc4179";
+/** GAN Gen2 protocol BLE command characteristic */
+export declare const GAN_GEN2_COMMAND_CHARACTERISTIC = "28be4a4a-cd67-11e9-a32f-2a2ae2dbcce4";
+/** GAN Gen2 protocol BLE state characteristic */
+export declare const GAN_GEN2_STATE_CHARACTERISTIC = "28be4cb6-cd67-11e9-a32f-2a2ae2dbcce4";
+/** GAN Gen3 protocol BLE service */
+export declare const GAN_GEN3_SERVICE = "8653000a-43e6-47b7-9cb0-5fc21d4ae340";
+/** GAN Gen3 protocol BLE command characteristic */
+export declare const GAN_GEN3_COMMAND_CHARACTERISTIC = "8653000c-43e6-47b7-9cb0-5fc21d4ae340";
+/** GAN Gen3 protocol BLE state characteristic */
+export declare const GAN_GEN3_STATE_CHARACTERISTIC = "8653000b-43e6-47b7-9cb0-5fc21d4ae340";
+/** GAN Gen4 protocol BLE service */
+export declare const GAN_GEN4_SERVICE = "00000010-0000-fff7-fff6-fff5fff4fff0";
+/** GAN Gen4 protocol BLE command characteristic */
+export declare const GAN_GEN4_COMMAND_CHARACTERISTIC = "0000fff5-0000-1000-8000-00805f9b34fb";
+/** GAN Gen4 protocol BLE state characteristic */
+export declare const GAN_GEN4_STATE_CHARACTERISTIC = "0000fff6-0000-1000-8000-00805f9b34fb";
+/** List of Company Identifier Codes, fill with all values [0x0001, 0xFF01] possible for GAN cubes */
+export declare const GAN_CIC_LIST: number[];
+/**  List of encryption keys */
+export declare const GAN_ENCRYPTION_KEYS: {
+    key: number[];
+    iv: number[];
+}[];

package/bluetooth/vendor/smartcube-web-bluetooth/gan-cube-definitions.js

@@ -0,0 +1,51 @@
+/** LZ-compressed key blobs for GAN gen1 `deriveKey`. */
+export const GAN_GEN1_COMPRESSED_KEYS = [
+    "NoRgnAHANATADDWJYwMxQOxiiEcfYgSK6Hpr4TYCs0IG1OEAbDszALpA",
+    "NoNg7ANATFIQnARmogLBRUCs0oAYN8U5J45EQBmFADg0oJAOSlUQF0g",
+    "NoRgNATGBs1gLABgQTjCeBWSUDsYBmKbCeMADjNnXxHIoIF0g",
+    "NoRg7ANAzBCsAMEAsioxBEIAc0Cc0ATJkgSIYhXIjhMQGxgC6QA",
+    "NoVgNAjAHGBMYDYCcdJgCwTFBkYVgAY9JpJYUsYBmAXSA",
+    "NoRgNAbAHGAsAMkwgMyzClH0LFcArHnAJzIqIBMGWEAukA",
+];
+/** GAN gen1 primary GATT service (356i “API v1”). */
+export const GAN_GEN1_PRIMARY_SERVICE = "0000fff0-0000-1000-8000-00805f9b34fb";
+/** Standard Device Information service (gen1 key derivation). */
+export const GAN_GEN1_DEVICE_INFO_SERVICE = "0000180a-0000-1000-8000-00805f9b34fb";
+export const GAN_GEN1_CHR_FIRMWARE = "00002a28-0000-1000-8000-00805f9b34fb";
+export const GAN_GEN1_CHR_HARDWARE = "00002a23-0000-1000-8000-00805f9b34fb";
+export const GAN_GEN1_CHR_STATE = "0000fff5-0000-1000-8000-00805f9b34fb";
+export const GAN_GEN1_CHR_MOVES = "0000fff6-0000-1000-8000-00805f9b34fb";
+export const GAN_GEN1_CHR_GYRO_NOTIFY = "0000fff4-0000-1000-8000-00805f9b34fb";
+export const GAN_GEN1_CHR_BATTERY = "0000fff7-0000-1000-8000-00805f9b34fb";
+export const GAN_GEN1_CHR_FACELETS = "0000fff2-0000-1000-8000-00805f9b34fb";
+/** GAN Gen2 protocol BLE service */
+export const GAN_GEN2_SERVICE = "6e400001-b5a3-f393-e0a9-e50e24dc4179";
+/** GAN Gen2 protocol BLE command characteristic */
+export const GAN_GEN2_COMMAND_CHARACTERISTIC = "28be4a4a-cd67-11e9-a32f-2a2ae2dbcce4";
+/** GAN Gen2 protocol BLE state characteristic */
+export const GAN_GEN2_STATE_CHARACTERISTIC = "28be4cb6-cd67-11e9-a32f-2a2ae2dbcce4";
+/** GAN Gen3 protocol BLE service */
+export const GAN_GEN3_SERVICE = "8653000a-43e6-47b7-9cb0-5fc21d4ae340";
+/** GAN Gen3 protocol BLE command characteristic */
+export const GAN_GEN3_COMMAND_CHARACTERISTIC = "8653000c-43e6-47b7-9cb0-5fc21d4ae340";
+/** GAN Gen3 protocol BLE state characteristic */
+export const GAN_GEN3_STATE_CHARACTERISTIC = "8653000b-43e6-47b7-9cb0-5fc21d4ae340";
+/** GAN Gen4 protocol BLE service */
+export const GAN_GEN4_SERVICE = "00000010-0000-fff7-fff6-fff5fff4fff0";
+/** GAN Gen4 protocol BLE command characteristic */
+export const GAN_GEN4_COMMAND_CHARACTERISTIC = "0000fff5-0000-1000-8000-00805f9b34fb";
+/** GAN Gen4 protocol BLE state characteristic */
+export const GAN_GEN4_STATE_CHARACTERISTIC = "0000fff6-0000-1000-8000-00805f9b34fb";
+/** List of Company Identifier Codes, fill with all values [0x0001, 0xFF01] possible for GAN cubes */
+export const GAN_CIC_LIST = Array(256).fill(undefined).map((_v, i) => (i << 8) | 0x01);
+/**  List of encryption keys */
+export const GAN_ENCRYPTION_KEYS = [
+    {
+        key: [0x01, 0x02, 0x42, 0x28, 0x31, 0x91, 0x16, 0x07, 0x20, 0x05, 0x18, 0x54, 0x42, 0x11, 0x12, 0x53],
+        iv: [0x11, 0x03, 0x32, 0x28, 0x21, 0x01, 0x76, 0x27, 0x20, 0x95, 0x78, 0x14, 0x32, 0x12, 0x02, 0x43]
+    },
+    {
+        key: [0x05, 0x12, 0x02, 0x45, 0x02, 0x01, 0x29, 0x56, 0x12, 0x78, 0x12, 0x76, 0x81, 0x01, 0x08, 0x03],
+        iv: [0x01, 0x44, 0x28, 0x06, 0x86, 0x21, 0x22, 0x28, 0x51, 0x05, 0x08, 0x31, 0x82, 0x02, 0x21, 0x06]
+    }
+];

package/bluetooth/vendor/smartcube-web-bluetooth/gan-cube-encrypter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Common cube encrypter interface
+ */
+interface GanCubeEncrypter {
+    /** Encrypt binary message buffer represented as Uint8Array */
+    encrypt(data: Uint8Array): Uint8Array;
+    /** Decrypt binary message buffer represented as Uint8Array */
+    decrypt(data: Uint8Array): Uint8Array;
+}
+/**
+ * Implementation for encryption scheme used in the GAN Gen2 Smart Cubes
+ */
+declare class GanGen2CubeEncrypter implements GanCubeEncrypter {
+    private _key;
+    private _iv;
+    constructor(key: Uint8Array, iv: Uint8Array, salt: Uint8Array);
+    /** Encrypt 16-byte buffer chunk starting at offset using AES-128-CBC */
+    private encryptChunk;
+    /** Decrypt 16-byte buffer chunk starting at offset using AES-128-CBC */
+    private decryptChunk;
+    encrypt(data: Uint8Array): Uint8Array;
+    decrypt(data: Uint8Array): Uint8Array;
+}
+/**
+ * Implementation for encryption scheme used in the GAN Gen3 cubes
+ */
+declare class GanGen3CubeEncrypter extends GanGen2CubeEncrypter {
+}
+/**
+ * Implementation for encryption scheme used in the GAN Gen3 cubes
+ */
+declare class GanGen4CubeEncrypter extends GanGen2CubeEncrypter {
+}
+export type { GanCubeEncrypter };
+export { GanGen2CubeEncrypter, GanGen3CubeEncrypter, GanGen4CubeEncrypter };