cubing 0.57.4 → 0.58.1

package/dist/lib/cubing/bluetooth/index.js

@@ -1,23 +1,23 @@
 import {
   binaryComponentsToReid3x3x3,
   twizzleBinaryToBinaryComponents
-} from "../chunks/chunk-7HQOMRBY.js";
+} from "../chunks/chunk-BVZN7IXO.js";
 import {
-  cube3x3x3,
   puzzles
-} from "../chunks/chunk-2H2XY6KQ.js";
+} from "../chunks/chunk-WI3YFILD.js";
 import {
+  cube3x3x3,
   experimental3x3x3KPuzzle
-} from "../chunks/chunk-666TWRT6.js";
+} from "../chunks/chunk-Z4CZPP2W.js";
 import {
   KPattern
-} from "../chunks/chunk-3YVVF3KK.js";
+} from "../chunks/chunk-CZGLT7LF.js";
 import {
   Alg,
   Move,
   experimentalAppendMove,
   keyToMove
-} from "../chunks/chunk-SWKNZGJF.js";
+} from "../chunks/chunk-3MMNI5O2.js";
 
 // src/cubing/bluetooth/debug.ts
 var DEBUG_LOGGING_ENABLED = false;
@@ -268,6 +268,12 @@ async function unsafeEncryptBlockWithIV(key, plaintextBlock, iv) {
   );
   return cryptoResult.slice(0, blockSize);
 }
+async function unsafeEncryptBlock(key, plaintextBlock) {
+  return (await unsafeEncryptBlockWithIV(key, plaintextBlock, zeros)).slice(
+    0,
+    blockSize
+  );
+}
 async function unsafeDecryptBlock(key, ciphertextBlock) {
   const paddingBlock = await unsafeEncryptBlockWithIV(
     key,
@@ -288,6 +294,52 @@ async function unsafeDecryptBlock(key, ciphertextBlock) {
   return cryptoResult.slice(0, blockSize);
 }
 
+// src/cubing/bluetooth/smart-puzzle/common.ts
+var reidEdgeOrder = "UF UR UB UL DF DR DB DL FR FL BR BL".split(" ");
+var reidCornerOrder = "UFR URB UBL ULF DRF DFL DLB DBR".split(" ");
+function rotateLeft(s, i) {
+  return s.slice(i) + s.slice(0, i);
+}
+var pieceMap = {};
+reidEdgeOrder.forEach((edge, idx) => {
+  for (let i = 0; i < 2; i++) {
+    pieceMap[rotateLeft(edge, i)] = { piece: idx, orientation: i };
+  }
+});
+reidCornerOrder.forEach((corner, idx) => {
+  for (let i = 0; i < 3; i++) {
+    pieceMap[rotateLeft(corner, i)] = { piece: idx, orientation: i };
+  }
+});
+function getPatternData(stickers, faceOrder3, edgeMappings, cornerMappings) {
+  const patternData = {
+    CORNERS: {
+      pieces: [],
+      orientation: []
+    },
+    EDGES: {
+      pieces: [],
+      orientation: []
+    },
+    CENTERS: {
+      pieces: [0, 1, 2, 3, 4, 5],
+      orientation: [0, 0, 0, 0, 0, 0],
+      orientationMod: [1, 1, 1, 1, 1, 1]
+    }
+  };
+  for (const cornerMapping of cornerMappings) {
+    const pieceInfo = pieceMap[cornerMapping.map((i) => faceOrder3[stickers[i]]).join("")];
+    patternData["CORNERS"].pieces.push(pieceInfo.piece);
+    patternData["CORNERS"].orientation.push(pieceInfo.orientation);
+  }
+  for (const edgeMapping of edgeMappings) {
+    const pieceInfo = pieceMap[edgeMapping.map((i) => faceOrder3[stickers[i]]).join("")];
+    patternData["EDGES"].pieces.push(pieceInfo.piece);
+    patternData["EDGES"].orientation.push(pieceInfo.orientation);
+  }
+  return patternData;
+}
+
 // src/cubing/bluetooth/smart-puzzle/gan.ts
 var DEFAULT_INTERVAL_MS = 150;
 var MAX_LATEST_MOVES = 6;
@@ -454,22 +506,6 @@ function buf2hex(buffer) {
     (x) => `00${x.toString(16)}`.slice(-2)
   ).join(" ");
 }
-var reidEdgeOrder = "UF UR UB UL DF DR DB DL FR FL BR BL".split(" ");
-var reidCornerOrder = "UFR URB UBL ULF DRF DFL DLB DBR".split(" ");
-function rotateLeft(s, i) {
-  return s.slice(i) + s.slice(0, i);
-}
-var pieceMap = {};
-reidEdgeOrder.forEach((edge, idx) => {
-  for (let i = 0; i < 2; i++) {
-    pieceMap[rotateLeft(edge, i)] = { piece: idx, orientation: i };
-  }
-});
-reidCornerOrder.forEach((corner, idx) => {
-  for (let i = 0; i < 3; i++) {
-    pieceMap[rotateLeft(corner, i)] = { piece: idx, orientation: i };
-  }
-});
 var gan356iCornerMappings = [
   [0, 21, 15],
   [5, 13, 47],
@@ -625,33 +661,15 @@ var GanCube = class _GanCube extends BluetoothPuzzle {
         v >>= 3;
       }
     }
-    const patternData = {
-      CORNERS: {
-        pieces: [],
-        orientation: []
-      },
-      EDGES: {
-        pieces: [],
-        orientation: []
-      },
-      CENTERS: {
-        pieces: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 0, 0, 0],
-        orientationMod: [1, 1, 1, 1, 1, 1]
-        // TODO
-      }
-    };
-    for (const cornerMapping of gan356iCornerMappings) {
-      const pieceInfo = pieceMap[cornerMapping.map((i) => faceOrder[stickers[i]]).join("")];
-      patternData["CORNERS"].pieces.push(pieceInfo.piece);
-      patternData["CORNERS"].orientation.push(pieceInfo.orientation);
-    }
-    for (const edgeMapping of gan356iEdgeMappings) {
-      const pieceInfo = pieceMap[edgeMapping.map((i) => faceOrder[stickers[i]]).join("")];
-      patternData["EDGES"].pieces.push(pieceInfo.piece);
-      patternData["EDGES"].orientation.push(pieceInfo.orientation);
-    }
-    return new KPattern(this.kpuzzle, patternData);
+    return new KPattern(
+      this.kpuzzle,
+      getPatternData(
+        stickers,
+        faceOrder,
+        gan356iEdgeMappings,
+        gan356iCornerMappings
+      )
+    );
   }
   async faceletStatus1Characteristic() {
     this.cachedFaceletStatus1Characteristic = this.cachedFaceletStatus1Characteristic || this.service.getCharacteristic(UUIDs.faceletStatus1Characteristic);
@@ -1198,11 +1216,636 @@ var heykubeConfig = {
   optionalServices: [UUIDs4.heykubeService]
 };
 
+// src/cubing/bluetooth/smart-puzzle/qiyi.ts
+var UUIDs5 = {
+  qiyiMainService: 65520,
+  qiyiMainCharacteristic: 65526
+};
+var qiyiMoveToBlockMove = {
+  1: new Move("L", -1),
+  2: new Move("L"),
+  3: new Move("R", -1),
+  4: new Move("R"),
+  5: new Move("D", -1),
+  6: new Move("D"),
+  7: new Move("U", -1),
+  8: new Move("U"),
+  9: new Move("F", -1),
+  10: new Move("F"),
+  11: new Move("B", -1),
+  12: new Move("B")
+};
+var faceOrder2 = "LRDUFB";
+var qiyiCornerMappings = [
+  [8, 20, 9],
+  // UFR,
+  [2, 11, 45],
+  // URB,
+  [0, 47, 36],
+  // UBL,
+  [6, 38, 18],
+  // ULF,
+  [29, 15, 26],
+  // DRF,
+  [27, 24, 44],
+  // DFL,
+  [33, 42, 53],
+  // DLB,
+  [35, 51, 17]
+  // DBR,
+];
+var qiyiEdgeMappings = [
+  [7, 19],
+  // UF,
+  [5, 10],
+  // UR,
+  [1, 46],
+  // UB,
+  [3, 37],
+  // UL,
+  [28, 25],
+  // DF,
+  [32, 16],
+  // DR,
+  [34, 52],
+  // DB,
+  [30, 43],
+  // DL,
+  [23, 12],
+  // FR,
+  [21, 41],
+  // FL,
+  [48, 14],
+  // BR,
+  [50, 39]
+  // BL,
+];
+function generateChecksum(data) {
+  const TABLE = new Uint16Array([
+    0,
+    49345,
+    49537,
+    320,
+    49921,
+    960,
+    640,
+    49729,
+    50689,
+    1728,
+    1920,
+    51009,
+    1280,
+    50625,
+    50305,
+    1088,
+    52225,
+    3264,
+    3456,
+    52545,
+    3840,
+    53185,
+    52865,
+    3648,
+    2560,
+    51905,
+    52097,
+    2880,
+    51457,
+    2496,
+    2176,
+    51265,
+    55297,
+    6336,
+    6528,
+    55617,
+    6912,
+    56257,
+    55937,
+    6720,
+    7680,
+    57025,
+    57217,
+    8e3,
+    56577,
+    7616,
+    7296,
+    56385,
+    5120,
+    54465,
+    54657,
+    5440,
+    55041,
+    6080,
+    5760,
+    54849,
+    53761,
+    4800,
+    4992,
+    54081,
+    4352,
+    53697,
+    53377,
+    4160,
+    61441,
+    12480,
+    12672,
+    61761,
+    13056,
+    62401,
+    62081,
+    12864,
+    13824,
+    63169,
+    63361,
+    14144,
+    62721,
+    13760,
+    13440,
+    62529,
+    15360,
+    64705,
+    64897,
+    15680,
+    65281,
+    16320,
+    16e3,
+    65089,
+    64001,
+    15040,
+    15232,
+    64321,
+    14592,
+    63937,
+    63617,
+    14400,
+    10240,
+    59585,
+    59777,
+    10560,
+    60161,
+    11200,
+    10880,
+    59969,
+    60929,
+    11968,
+    12160,
+    61249,
+    11520,
+    60865,
+    60545,
+    11328,
+    58369,
+    9408,
+    9600,
+    58689,
+    9984,
+    59329,
+    59009,
+    9792,
+    8704,
+    58049,
+    58241,
+    9024,
+    57601,
+    8640,
+    8320,
+    57409,
+    40961,
+    24768,
+    24960,
+    41281,
+    25344,
+    41921,
+    41601,
+    25152,
+    26112,
+    42689,
+    42881,
+    26432,
+    42241,
+    26048,
+    25728,
+    42049,
+    27648,
+    44225,
+    44417,
+    27968,
+    44801,
+    28608,
+    28288,
+    44609,
+    43521,
+    27328,
+    27520,
+    43841,
+    26880,
+    43457,
+    43137,
+    26688,
+    30720,
+    47297,
+    47489,
+    31040,
+    47873,
+    31680,
+    31360,
+    47681,
+    48641,
+    32448,
+    32640,
+    48961,
+    32e3,
+    48577,
+    48257,
+    31808,
+    46081,
+    29888,
+    30080,
+    46401,
+    30464,
+    47041,
+    46721,
+    30272,
+    29184,
+    45761,
+    45953,
+    29504,
+    45313,
+    29120,
+    28800,
+    45121,
+    20480,
+    37057,
+    37249,
+    20800,
+    37633,
+    21440,
+    21120,
+    37441,
+    38401,
+    22208,
+    22400,
+    38721,
+    21760,
+    38337,
+    38017,
+    21568,
+    39937,
+    23744,
+    23936,
+    40257,
+    24320,
+    40897,
+    40577,
+    24128,
+    23040,
+    39617,
+    39809,
+    23360,
+    39169,
+    22976,
+    22656,
+    38977,
+    34817,
+    18624,
+    18816,
+    35137,
+    19200,
+    35777,
+    35457,
+    19008,
+    19968,
+    36545,
+    36737,
+    20288,
+    36097,
+    19904,
+    19584,
+    35905,
+    17408,
+    33985,
+    34177,
+    17728,
+    34561,
+    18368,
+    18048,
+    34369,
+    33281,
+    17088,
+    17280,
+    33601,
+    16640,
+    33217,
+    32897,
+    16448
+  ]);
+  let crc = 65535;
+  for (const dataPoint of data) {
+    const xor = (dataPoint ^ crc) & 255;
+    crc >>= 8;
+    crc ^= TABLE[xor];
+  }
+  return crc;
+}
+async function prepareMessage(message, aesKey) {
+  const messageCopyForChecksum = structuredClone(message);
+  const checksum = generateChecksum(messageCopyForChecksum);
+  messageCopyForChecksum.push(checksum & 255);
+  messageCopyForChecksum.push(checksum >> 8);
+  const paddedLength = Math.ceil(messageCopyForChecksum.length / 16) * 16;
+  const paddedArray = new Uint8Array([
+    ...messageCopyForChecksum,
+    ...Array(paddedLength - messageCopyForChecksum.length).fill(0)
+  ]);
+  const encryptedMessage = new Uint8Array(paddedLength);
+  for (let i = 0; i < paddedArray.length / 16; i++) {
+    const encryptedBlock = new Uint8Array(
+      await unsafeEncryptBlock(aesKey, paddedArray.slice(i * 16, (i + 1) * 16))
+    );
+    encryptedMessage.set(encryptedBlock, i * 16);
+  }
+  return encryptedMessage;
+}
+async function decryptMessage(encryptedMessage, aesKey) {
+  const decryptedMessage = new Uint8Array(encryptedMessage.length);
+  for (let i = 0; i < encryptedMessage.length / 16; i++) {
+    const decryptedBlock = new Uint8Array(
+      await unsafeDecryptBlock(
+        aesKey,
+        encryptedMessage.slice(i * 16, (i + 1) * 16)
+      )
+    );
+    decryptedMessage.set(decryptedBlock, i * 16);
+  }
+  return decryptedMessage;
+}
+function getMacAddress(device) {
+  if (device.name === void 0) {
+    return;
+  }
+  return [
+    204,
+    163,
+    0,
+    0,
+    parseInt(device.name.slice(10, 12), 16),
+    parseInt(device.name.slice(12, 14), 16)
+  ];
+}
+var MAX_TIMESTAMP_COUNT = 12;
+var TIMESTAMP_SCALE = 1.6;
+var CUBE_HELLO = 2;
+var STATE_CHANGE = 3;
+var QiyiCube = class _QiyiCube extends BluetoothPuzzle {
+  constructor(kpuzzle, aesKey, server) {
+    super();
+    this.kpuzzle = kpuzzle;
+    this.aesKey = aesKey;
+    this.server = server;
+    this.startNotifications().then(this.sendAppHello.bind(this));
+    this.allTimeStamps = /* @__PURE__ */ new Set();
+    this.allTimeStampsQueue = [];
+  }
+  latestTimestamp;
+  allTimeStamps;
+  // Without this set, moves are constantly duplicated
+  allTimeStampsQueue;
+  stickers = [
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5
+  ];
+  batteryLevel = 100;
+  static async connect(server) {
+    const aesKey = await importKey(
+      new Uint8Array([
+        87,
+        177,
+        249,
+        171,
+        205,
+        90,
+        232,
+        167,
+        156,
+        185,
+        140,
+        231,
+        87,
+        140,
+        81,
+        8
+      ])
+    );
+    return new _QiyiCube(await puzzles["3x3x3"].kpuzzle(), aesKey, server);
+  }
+  async sendAppHello() {
+    const mainService = await this.server.getPrimaryService(
+      UUIDs5.qiyiMainService
+    );
+    const mainCharacteristic = await mainService.getCharacteristic(
+      UUIDs5.qiyiMainCharacteristic
+    );
+    for (let macGuessCounter = 0; macGuessCounter < 8; macGuessCounter++) {
+      const mac = getMacAddress(this.server.device);
+      mac[3] = macGuessCounter;
+      const reversedMac = mac.reverse();
+      const appHello = [
+        254,
+        21,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        ...reversedMac
+      ];
+      const appHelloMessage = await prepareMessage(appHello, this.aesKey);
+      await mainCharacteristic.writeValue(appHelloMessage);
+    }
+  }
+  async startNotifications() {
+    const mainService = await this.server.getPrimaryService(
+      UUIDs5.qiyiMainService
+    );
+    const mainCharacteristic = await mainService.getCharacteristic(
+      UUIDs5.qiyiMainCharacteristic
+    );
+    mainCharacteristic.addEventListener(
+      "characteristicvaluechanged",
+      this.cubeMessageHandler.bind(this)
+    );
+    await mainCharacteristic.startNotifications();
+  }
+  async cubeMessageHandler(event) {
+    const characteristic = event.target;
+    const decryptedMessage = await decryptMessage(
+      new Uint8Array(characteristic.value.buffer),
+      this.aesKey
+    );
+    const opCode = decryptedMessage[2];
+    let needsAck = false;
+    switch (opCode) {
+      case CUBE_HELLO: {
+        const initialState = decryptedMessage.slice(7, 34);
+        this.updateState(initialState);
+        this.batteryLevel = decryptedMessage[35];
+        needsAck = true;
+        break;
+      }
+      case STATE_CHANGE: {
+        const state = decryptedMessage.slice(7, 34);
+        this.updateState(state);
+        const latestMove = qiyiMoveToBlockMove[decryptedMessage[34]];
+        const latestTimestamp = new DataView(
+          decryptedMessage.slice(3, 7).buffer
+        ).getInt32(0);
+        const moves = [[latestMove, latestTimestamp]];
+        const previousMoves = new DataView(
+          decryptedMessage.slice(36, 91).buffer
+        );
+        for (let i = previousMoves.byteLength - 1; i > 0 && previousMoves.getUint8(i) !== 255; i -= 5) {
+          const move = qiyiMoveToBlockMove[previousMoves.getUint8(i)];
+          const timestamp = previousMoves.getUint32(i - 4);
+          if (this.latestTimestamp === void 0 || timestamp <= this.latestTimestamp) {
+            continue;
+          }
+          moves.push([move, timestamp]);
+        }
+        moves.sort((a, b) => a[1] - b[1]);
+        for (const move of moves) {
+          const latestAlgLeaf = move[0];
+          const timeStamp = Math.round(move[1] / TIMESTAMP_SCALE);
+          if (!this.allTimeStamps.has(timeStamp)) {
+            this.dispatchAlgLeaf({
+              latestAlgLeaf,
+              timeStamp
+            });
+            this.allTimeStamps.add(timeStamp);
+            this.allTimeStampsQueue.push(timeStamp);
+            if (this.allTimeStampsQueue.length > MAX_TIMESTAMP_COUNT) {
+              this.allTimeStamps.delete(this.allTimeStampsQueue.shift());
+            }
+          }
+        }
+        this.latestTimestamp = latestTimestamp;
+        needsAck = decryptedMessage[91] === 1;
+        break;
+      }
+      default:
+        console.error(`Opcode not implemented: ${opCode}`);
+        break;
+    }
+    if (needsAck) {
+      await characteristic.writeValue(
+        await prepareMessage(
+          [254, 9, ...decryptedMessage.slice(2, 7)],
+          this.aesKey
+        )
+      );
+    }
+  }
+  updateState(state) {
+    this.stickers = Array.from(state).flatMap((twoPieces) => [
+      twoPieces & 15,
+      twoPieces >> 4
+    ]);
+  }
+  name() {
+    return this.server.device.name;
+  }
+  disconnect() {
+    this.server.disconnect();
+  }
+  async getPattern() {
+    return new KPattern(
+      this.kpuzzle,
+      getPatternData(
+        this.stickers,
+        faceOrder2,
+        qiyiEdgeMappings,
+        qiyiCornerMappings
+      )
+    );
+  }
+  getBattery() {
+    return this.batteryLevel;
+  }
+};
+var qiyiConfig = {
+  connect: QiyiCube.connect.bind(QiyiCube),
+  prefixes: ["QY-QYSC"],
+  filters: [
+    {
+      namePrefix: "QY-QYSC"
+    }
+  ],
+  optionalServices: [UUIDs5.qiyiMainService]
+};
+
 // src/cubing/bluetooth/smart-puzzle/connect.ts
 var smartPuzzleConfigs = [
   ganConfig,
   goCubeConfig,
   heykubeConfig,
+  qiyiConfig,
   giiKERConfig
   // GiiKER must be last, due to Xiaomi naming. TODO: enforce this using tests.
 ];
@@ -1224,7 +1867,7 @@ var U_D_SWAP = new Alg("F B R2 L2 B' F'");
 var U_D_UNSWAP = U_D_SWAP.invert();
 var F_B_SWAP = new Alg("U D R2 L2 D' U'");
 var F_B_UNSWAP = F_B_SWAP.invert();
-var UUIDs5 = {
+var UUIDs6 = {
   ganRobotService: "0000fff0-0000-1000-8000-00805f9b34fb",
   statusCharacteristic: "0000fff2-0000-1000-8000-00805f9b34fb",
   moveCharacteristic: "0000fff3-0000-1000-8000-00805f9b34fb"
@@ -1310,13 +1953,13 @@ var GanRobot = class _GanRobot extends EventTarget {
   // We have to perform async operations before we call the constructor.
   static async connect(server, device) {
     const ganTimerService = await server.getPrimaryService(
-      UUIDs5.ganRobotService
+      UUIDs6.ganRobotService
     );
     const statusCharacteristic = await ganTimerService.getCharacteristic(
-      UUIDs5.statusCharacteristic
+      UUIDs6.statusCharacteristic
     );
     const moveCharacteristic = await ganTimerService.getCharacteristic(
-      UUIDs5.moveCharacteristic
+      UUIDs6.moveCharacteristic
     );
     const timer = new _GanRobot(
       ganTimerService,
@@ -1470,7 +2113,7 @@ var ganTimerConfig = {
   connect: GanRobot.connect.bind(GanRobot),
   prefixes: ["GAN"],
   filters: [{ namePrefix: "GAN" }],
-  optionalServices: [UUIDs5.ganRobotService]
+  optionalServices: [UUIDs6.ganRobotService]
 };
 
 // src/cubing/bluetooth/smart-robot/index.ts
@@ -1480,7 +2123,7 @@ async function connectSmartRobot(options) {
 }
 
 // src/cubing/bluetooth/smart-timer/GanTimer.ts
-var UUIDs6 = {
+var UUIDs7 = {
   ganTimerService: "0000fff0-0000-1000-8000-00805f9b34fb",
   timeCharacteristic: "0000fff2-0000-1000-8000-00805f9b34fb"
 };
@@ -1501,11 +2144,11 @@ var GanTimer = class _GanTimer extends EventTarget {
   // We have to perform async operations before we call the constructor.
   static async connect(server, device) {
     const ganTimerService = await server.getPrimaryService(
-      UUIDs6.ganTimerService
+      UUIDs7.ganTimerService
     );
     console.log("Service:", ganTimerService);
     const timeCharacteristic = await ganTimerService.getCharacteristic(
-      UUIDs6.timeCharacteristic
+      UUIDs7.timeCharacteristic
     );
     console.log("Characteristic:", timeCharacteristic);
     const timer = new _GanTimer(
@@ -1576,7 +2219,7 @@ var ganTimerConfig2 = {
   connect: GanTimer.connect.bind(GanTimer),
   prefixes: ["GAN"],
   filters: [{ namePrefix: "GAN" }],
-  optionalServices: [UUIDs6.ganTimerService]
+  optionalServices: [UUIDs7.ganTimerService]
 };
 
 // src/cubing/bluetooth/smart-timer/index.ts