@vlydev/cs2-masked-inspect 1.0.0

package/src/ItemPreviewData.js

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+ * Represents a CS2 item as encoded in an inspect link.
+ *
+ * Fields map directly to the CEconItemPreviewDataBlock protobuf message
+ * used by the CS2 game coordinator.
+ *
+ * paintwear is stored as a float32 (IEEE 754). On the wire it is reinterpreted
+ * as a uint32 — this class always exposes it as a JavaScript number for convenience.
+ *
+ * accountid and itemid may be large integers; they are stored as BigInt internally
+ * but exposed as Number when they fit safely (< 2^53).
+ */
+class ItemPreviewData {
+  /**
+   * @param {object} [opts]
+   * @param {number}  [opts.accountId=0]
+   * @param {number}  [opts.itemId=0]
+   * @param {number}  [opts.defIndex=0]
+   * @param {number}  [opts.paintIndex=0]
+   * @param {number}  [opts.rarity=0]
+   * @param {number}  [opts.quality=0]
+   * @param {number}  [opts.paintWear=0.0]
+   * @param {number}  [opts.paintSeed=0]
+   * @param {number}  [opts.killEaterScoreType=0]
+   * @param {number}  [opts.killEaterValue=0]
+   * @param {string}  [opts.customName='']
+   * @param {import('./Sticker')[]} [opts.stickers=[]]
+   * @param {number}  [opts.inventory=0]
+   * @param {number}  [opts.origin=0]
+   * @param {number}  [opts.questId=0]
+   * @param {number}  [opts.dropReason=0]
+   * @param {number}  [opts.musicIndex=0]
+   * @param {number}  [opts.entIndex=0]
+   * @param {number}  [opts.petIndex=0]
+   * @param {import('./Sticker')[]} [opts.keychains=[]]
+   */
+  constructor({
+    accountId = 0,
+    itemId = 0,
+    defIndex = 0,
+    paintIndex = 0,
+    rarity = 0,
+    quality = 0,
+    paintWear = 0.0,
+    paintSeed = 0,
+    killEaterScoreType = 0,
+    killEaterValue = 0,
+    customName = '',
+    stickers = [],
+    inventory = 0,
+    origin = 0,
+    questId = 0,
+    dropReason = 0,
+    musicIndex = 0,
+    entIndex = 0,
+    petIndex = 0,
+    keychains = [],
+  } = {}) {
+    this.accountId = accountId;
+    this.itemId = itemId;
+    this.defIndex = defIndex;
+    this.paintIndex = paintIndex;
+    this.rarity = rarity;
+    this.quality = quality;
+    this.paintWear = paintWear;
+    this.paintSeed = paintSeed;
+    this.killEaterScoreType = killEaterScoreType;
+    this.killEaterValue = killEaterValue;
+    this.customName = customName;
+    this.stickers = stickers;
+    this.inventory = inventory;
+    this.origin = origin;
+    this.questId = questId;
+    this.dropReason = dropReason;
+    this.musicIndex = musicIndex;
+    this.entIndex = entIndex;
+    this.petIndex = petIndex;
+    this.keychains = keychains;
+  }
+}
+
+module.exports = ItemPreviewData;

package/src/Sticker.js

@@ -0,0 +1,48 @@
+'use strict';
+
+/**
+ * Represents a sticker or keychain applied to a CS2 item.
+ *
+ * Maps to the Sticker protobuf message nested inside CEconItemPreviewDataBlock.
+ * The same message is used for both stickers (field 12) and keychains (field 20).
+ */
+class Sticker {
+  /**
+   * @param {object} [opts]
+   * @param {number}  [opts.slot=0]
+   * @param {number}  [opts.stickerId=0]
+   * @param {number|null} [opts.wear=null]
+   * @param {number|null} [opts.scale=null]
+   * @param {number|null} [opts.rotation=null]
+   * @param {number}  [opts.tintId=0]
+   * @param {number|null} [opts.offsetX=null]
+   * @param {number|null} [opts.offsetY=null]
+   * @param {number|null} [opts.offsetZ=null]
+   * @param {number}  [opts.pattern=0]
+   */
+  constructor({
+    slot = 0,
+    stickerId = 0,
+    wear = null,
+    scale = null,
+    rotation = null,
+    tintId = 0,
+    offsetX = null,
+    offsetY = null,
+    offsetZ = null,
+    pattern = 0,
+  } = {}) {
+    this.slot = slot;
+    this.stickerId = stickerId;
+    this.wear = wear;
+    this.scale = scale;
+    this.rotation = rotation;
+    this.tintId = tintId;
+    this.offsetX = offsetX;
+    this.offsetY = offsetY;
+    this.offsetZ = offsetZ;
+    this.pattern = pattern;
+  }
+}
+
+module.exports = Sticker;

package/src/proto/reader.js

@@ -0,0 +1,128 @@
+'use strict';
+
+/**
+ * Pure JavaScript protobuf binary reader.
+ *
+ * Implements the subset of wire types needed for CEconItemPreviewDataBlock:
+ *   - Wire type 0: varint (uint32, uint64, int32)
+ *   - Wire type 2: length-delimited (string, bytes, nested messages)
+ *   - Wire type 5: 32-bit fixed (float32)
+ */
+
+const WIRE_VARINT = 0;
+const WIRE_64BIT  = 1;
+const WIRE_LEN    = 2;
+const WIRE_32BIT  = 5;
+
+class ProtoReader {
+  /**
+   * @param {Buffer} data
+   */
+  constructor(data) {
+    this._data = data;
+    this._pos  = 0;
+  }
+
+  get pos() {
+    return this._pos;
+  }
+
+  remaining() {
+    return this._data.length - this._pos;
+  }
+
+  readByte() {
+    if (this._pos >= this._data.length) {
+      throw new RangeError('Unexpected end of protobuf data');
+    }
+    return this._data[this._pos++];
+  }
+
+  readBytes(n) {
+    if (this._pos + n > this._data.length) {
+      throw new RangeError(
+        `Need ${n} bytes but only ${this._data.length - this._pos} remain`,
+      );
+    }
+    const chunk = this._data.slice(this._pos, this._pos + n);
+    this._pos += n;
+    return chunk;
+  }
+
+  /**
+   * Read a base-128 varint.
+   * Returns a BigInt for 64-bit range safety; callers convert as needed.
+   *
+   * @returns {bigint}
+   */
+  readVarint() {
+    let result = 0n;
+    let shift  = 0n;
+
+    while (true) {
+      const b = this.readByte();
+      result |= BigInt(b & 0x7F) << shift;
+      if (!(b & 0x80)) break;
+      shift += 7n;
+      if (shift > 63n) {
+        throw new RangeError('Varint too long');
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Read tag and return [fieldNumber, wireType].
+   *
+   * @returns {[number, number]}
+   */
+  readTag() {
+    const tag = this.readVarint();
+    return [Number(tag >> 3n), Number(tag & 7n)];
+  }
+
+  readLengthDelimited() {
+    const length = Number(this.readVarint());
+    return this.readBytes(length);
+  }
+
+  /**
+   * Read all fields until EOF.
+   *
+   * @returns {Array<{field: number, wire: number, value: bigint|Buffer}>}
+   */
+  readAllFields() {
+    const fields = [];
+
+    while (this.remaining() > 0) {
+      const [fieldNum, wireType] = this.readTag();
+
+      let value;
+      switch (wireType) {
+        case WIRE_VARINT:
+          value = this.readVarint();
+          break;
+        case WIRE_64BIT:
+          value = this.readBytes(8);
+          break;
+        case WIRE_LEN:
+          value = this.readLengthDelimited();
+          break;
+        case WIRE_32BIT:
+          value = this.readBytes(4);
+          break;
+        default:
+          throw new RangeError(
+            `Unknown wire type ${wireType} for field ${fieldNum}`,
+          );
+      }
+
+      fields.push({ field: fieldNum, wire: wireType, value });
+    }
+
+    return fields;
+  }
+}
+
+module.exports = { ProtoReader, WIRE_VARINT, WIRE_64BIT, WIRE_LEN, WIRE_32BIT };

package/src/proto/writer.js

@@ -0,0 +1,137 @@
+'use strict';
+
+/**
+ * Pure JavaScript protobuf binary writer.
+ *
+ * Writes to an in-memory buffer; call toBytes() to retrieve the result.
+ * Fields with default/zero values are omitted (proto3 semantics).
+ */
+
+const WIRE_VARINT = 0;
+const WIRE_LEN    = 2;
+const WIRE_32BIT  = 5;
+
+class ProtoWriter {
+  constructor() {
+    /** @type {Buffer[]} */
+    this._buf = [];
+  }
+
+  toBytes() {
+    return Buffer.concat(this._buf);
+  }
+
+  // ------------------------------------------------------------------
+  // Low-level primitives
+  // ------------------------------------------------------------------
+
+  /**
+   * @param {bigint|number} value
+   */
+  _writeVarint(value) {
+    let v = BigInt(value);
+    // Handle negative: treat as unsigned 64-bit two's complement
+    if (v < 0n) {
+      v = BigInt.asUintN(64, v);
+    }
+
+    const parts = [];
+    do {
+      let b = Number(v & 0x7Fn);
+      v >>= 7n;
+      if (v !== 0n) b |= 0x80;
+      parts.push(b);
+    } while (v !== 0n);
+
+    this._buf.push(Buffer.from(parts));
+  }
+
+  _writeTag(fieldNum, wireType) {
+    this._writeVarint((fieldNum << 3) | wireType);
+  }
+
+  // ------------------------------------------------------------------
+  // Public field writers
+  // ------------------------------------------------------------------
+
+  /**
+   * @param {number} fieldNum
+   * @param {number|bigint} value
+   */
+  writeUint32(fieldNum, value) {
+    if (value === 0 || value === 0n) return;
+    this._writeTag(fieldNum, WIRE_VARINT);
+    this._writeVarint(value);
+  }
+
+  /**
+   * @param {number} fieldNum
+   * @param {number|bigint} value
+   */
+  writeUint64(fieldNum, value) {
+    if (value === 0 || value === 0n) return;
+    this._writeTag(fieldNum, WIRE_VARINT);
+    this._writeVarint(value);
+  }
+
+  /**
+   * @param {number} fieldNum
+   * @param {number|bigint} value
+   */
+  writeInt32(fieldNum, value) {
+    if (value === 0 || value === 0n) return;
+    this._writeTag(fieldNum, WIRE_VARINT);
+    this._writeVarint(value);
+  }
+
+  /**
+   * @param {number} fieldNum
+   * @param {string} value
+   */
+  writeString(fieldNum, value) {
+    if (!value) return;
+    const encoded = Buffer.from(value, 'utf8');
+    this._writeTag(fieldNum, WIRE_LEN);
+    this._writeVarint(encoded.length);
+    this._buf.push(encoded);
+  }
+
+  /**
+   * Write a float32 as wire type 5 (fixed 32-bit, little-endian).
+   * Used for sticker float fields (wear, scale, rotation, etc.).
+   *
+   * @param {number} fieldNum
+   * @param {number} value
+   */
+  writeFloat32Fixed(fieldNum, value) {
+    this._writeTag(fieldNum, WIRE_32BIT);
+    const b = Buffer.alloc(4);
+    b.writeFloatLE(value, 0);
+    this._buf.push(b);
+  }
+
+  /**
+   * Write raw bytes as a length-delimited field (wire type 2).
+   *
+   * @param {number} fieldNum
+   * @param {Buffer} data
+   */
+  writeRawBytes(fieldNum, data) {
+    if (!data || data.length === 0) return;
+    this._writeTag(fieldNum, WIRE_LEN);
+    this._writeVarint(data.length);
+    this._buf.push(data);
+  }
+
+  /**
+   * Write a nested message (another ProtoWriter's output) as a length-delimited field.
+   *
+   * @param {number} fieldNum
+   * @param {ProtoWriter} nested
+   */
+  writeEmbedded(fieldNum, nested) {
+    this.writeRawBytes(fieldNum, nested.toBytes());
+  }
+}
+
+module.exports = { ProtoWriter, WIRE_VARINT, WIRE_LEN, WIRE_32BIT };