whalibmob 2.0.0

package/lib/noise.js

@@ -0,0 +1,371 @@
+'use strict';
+
+const net          = require('net');
+const crypto       = require('crypto');
+const EventEmitter = require('events');
+const curveJs      = require('curve25519-js');
+const { sha256 }   = require('@noble/hashes/sha256');
+const { hkdf }     = require('@noble/hashes/hkdf');
+const { MOBILE_PROLOGUE, WHATSAPP_HOST, WHATSAPP_PORT } = require('./constants');
+const { encodeHandshakeClientHello, encodeHandshakeClientFinish,
+        decodeServerHello, encodeClientPayload } = require('./proto');
+
+// ─── Curve25519 DH helpers ───────────────────────────────────────────────────
+
+function stripKeyPrefix(pub) {
+  if (pub.length === 33 && pub[0] === 0x05) return pub.slice(1);
+  if (pub.length === 32) return pub;
+  throw new Error('Invalid DH public key length: ' + pub.length);
+}
+
+function dhShared(privKey32, pubKey) {
+  return Buffer.from(curveJs.sharedKey(privKey32, stripKeyPrefix(pubKey)));
+}
+
+// ─── Noise_XX_25519_AESGCM_SHA256 ────────────────────────────────────────────
+
+const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
+
+function hash256(data) {
+  return Buffer.from(sha256(data));
+}
+
+function aesgcmEncrypt(key, counter, plaintext, aad) {
+  const iv = Buffer.alloc(12);
+  iv.writeBigUInt64BE(BigInt(counter), 4);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+  if (aad) cipher.setAAD(aad);
+  const enc = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([enc, tag]);
+}
+
+function aesgcmDecrypt(key, counter, ciphertext, aad) {
+  const iv  = Buffer.alloc(12);
+  iv.writeBigUInt64BE(BigInt(counter), 4);
+  const tag  = ciphertext.slice(ciphertext.length - 16);
+  const data = ciphertext.slice(0, ciphertext.length - 16);
+  const dec  = crypto.createDecipheriv('aes-256-gcm', key, iv);
+  dec.setAuthTag(tag);
+  if (aad) dec.setAAD(aad);
+  return Buffer.concat([dec.update(data), dec.final()]);
+}
+
+function deriveHkdf(salt, ikm, length) {
+  return Buffer.from(hkdf(sha256, ikm, salt, new Uint8Array(0), length));
+}
+
+class NoiseState {
+  constructor() {
+    // Noise spec: if protocol_name.length <= HASHLEN(32), h = protocol_name padded with zeros.
+    // Do NOT hash — use the raw 32-byte name directly as the initial h and ck.
+    const modeBytes = Buffer.from(NOISE_MODE, 'utf8'); // 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0' = 32 bytes
+    this.h       = modeBytes;
+    this.ck      = Buffer.from(modeBytes);
+    this.key     = null;  // single key for both enc+dec during handshake (matches Cobalt)
+    this.counter = 0;     // single counter for both encrypt+decrypt (matches Cobalt)
+    this.hash(MOBILE_PROLOGUE);
+  }
+
+  hash(data) {
+    this.h = hash256(Buffer.concat([this.h, data]));
+  }
+
+  mixKey(dhResult) {
+    const derived = deriveHkdf(this.ck, dhResult, 64);
+    this.ck      = derived.slice(0, 32);
+    this.key     = derived.slice(32, 64);
+    this.counter = 0;
+  }
+
+  encryptWithAd(plaintext) {
+    const ciphertext = aesgcmEncrypt(this.key, this.counter++, plaintext, this.h);
+    this.hash(ciphertext);
+    return ciphertext;
+  }
+
+  decryptWithAd(ciphertext) {
+    const plaintext = aesgcmDecrypt(this.key, this.counter++, ciphertext, this.h);
+    this.hash(ciphertext);
+    return plaintext;
+  }
+
+  split() {
+    const derived = deriveHkdf(this.ck, Buffer.alloc(0), 64);
+    return {
+      writeKey: derived.slice(0, 32),
+      readKey:  derived.slice(32, 64)
+    };
+  }
+}
+
+// ─── Frame helpers ────────────────────────────────────────────────────────────
+
+// Cobalt writeRequestHeader: writes 6 bytes (4 for upper part + 2 for lower).
+// Used for ALL outgoing frames (client → server).
+function makeFrame(payload) {
+  const len    = payload.length;
+  const header = Buffer.alloc(6);
+  const mss    = len >> 16;
+  header[0] = (mss >> 24) & 0xff;
+  header[1] = (mss >> 16) & 0xff;
+  header[2] = (mss >>  8) & 0xff;
+  header[3] =  mss        & 0xff;
+  const lss    = len & 0xffff;
+  header[4] = (lss >> 8) & 0xff;
+  header[5] =  lss       & 0xff;
+  return Buffer.concat([header, payload]);
+}
+
+// Cobalt messageLengthBuffer: always 3 bytes (server → client).
+function readFrameLength(data) {
+  if (data.length < 3) return -1;
+  return (data[0] << 16) | (data[1] << 8) | data[2];
+}
+
+// ─── NoiseSocket ─────────────────────────────────────────────────────────────
+//
+// Events emitted:
+//   'open'        — handshake complete, channel secured
+//   'node'(node)  — received a decoded BinaryNode
+//   'close'       — TCP connection closed
+//   'error'(err)  — an error occurred
+//
+class NoiseSocket extends EventEmitter {
+  constructor(store) {
+    super();
+    this.store        = store;
+    this.socket       = null;
+    this.noiseState   = null;
+    this.writeKey     = null;
+    this.readKey      = null;
+    this.writeCounter = 0;
+    this.readCounter  = 0;
+    this.connected    = false;
+    this.secured      = false;
+    this._awaitingAuth = false;  // true after ClientFinish sent, before server <success>/<failure>
+    this.rxBuf        = Buffer.alloc(0);
+    this._ephemeralKeyPair = null;
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      this._connectResolve = resolve;
+      this._connectReject  = reject;
+
+      this.socket = net.createConnection({ host: WHATSAPP_HOST, port: WHATSAPP_PORT });
+      this.socket.on('connect', () => this._onTcpConnect());
+      this.socket.on('data',    (data) => this._onData(data));
+      this.socket.on('error',   (err)  => this._onTcpError(err));
+      this.socket.on('close',   ()     => this._onTcpClose());
+    });
+  }
+
+  _onTcpConnect() {
+    this.connected = true;
+    this._startHandshake();
+  }
+
+  _startHandshake() {
+    this.noiseState    = new NoiseState();
+    const seed         = crypto.randomBytes(32);
+    const kp           = curveJs.generateKeyPair(seed);
+    this._ephemeralKeyPair = {
+      private: Buffer.from(kp.private),
+      public:  Buffer.from(kp.public)
+    };
+    this.noiseState.hash(this._ephemeralKeyPair.public);
+
+    const helloPayload = encodeHandshakeClientHello(this._ephemeralKeyPair.public);
+    const frame        = Buffer.concat([MOBILE_PROLOGUE, makeFrame(helloPayload)]);
+    this.socket.write(frame);
+  }
+
+  _onData(data) {
+    this.rxBuf = Buffer.concat([this.rxBuf, data]);
+    this._processBuffer();
+  }
+
+  _processBuffer() {
+    while (true) {
+      if (this.rxBuf.length < 3) break;
+      const frameLen = readFrameLength(this.rxBuf);
+      if (this.rxBuf.length < 3 + frameLen) break;
+      const frame    = this.rxBuf.slice(3, 3 + frameLen);
+      this.rxBuf     = this.rxBuf.slice(3 + frameLen);
+
+      if (!this.secured) {
+        this._handleHandshakeFrame(frame);
+      } else {
+        this._handleSecuredFrame(frame);
+      }
+    }
+  }
+
+  _handleHandshakeFrame(frame) {
+    try {
+      const serverHello = decodeServerHello(frame);
+      if (!serverHello.ephemeral) throw new Error('No server ephemeral in ServerHello');
+
+      this.noiseState.hash(serverHello.ephemeral);
+      const sharedEE  = dhShared(this._ephemeralKeyPair.private, serverHello.ephemeral);
+      this.noiseState.mixKey(sharedEE);
+
+      const serverStaticDec = this.noiseState.decryptWithAd(serverHello.staticEnc);
+      const sharedSE        = dhShared(this._ephemeralKeyPair.private, serverStaticDec);
+      this.noiseState.mixKey(sharedSE);
+
+      if (serverHello.payload) {
+        this.noiseState.decryptWithAd(serverHello.payload);
+      }
+
+      const noisePriv  = this.store.noiseKeyPair.private;
+      // Send the raw 32-byte noise public key (no 0x05 Signal prefix) — matches Baileys/WA protocol
+      const noisePub   = stripKeyPrefix(this.store.noiseKeyPair.public);
+      const encStatic  = this.noiseState.encryptWithAd(noisePub);
+      const sharedSS   = dhShared(noisePriv, serverHello.ephemeral);
+      this.noiseState.mixKey(sharedSS);
+
+      const payload = encodeClientPayload({
+        username:           BigInt(this.store.phoneNumber),
+        passive:            false,
+        pushName:           this.store.name || 'User',
+        shortConnect:       true,
+        connectType:        1,
+        connectReason:      1,
+        connectAttemptCount: 0,
+        device:             0,
+        oc:                 false,
+        userAgent: {
+          platform:        1,
+          version:         this.store.version,
+          mcc:             '000',
+          mnc:             '000',
+          osVersion:       this.store.device.osVersion,
+          manufacturer:    this.store.device.manufacturer,
+          device:          this.store.device.model,
+          osBuildNumber:   this.store.device.osBuildNumber,
+          phoneId:         this.store.fdid.toUpperCase(),
+          releaseChannel:  0,
+          localeLanguage:  'en',
+          localeCountry:   'US',
+          deviceType:      0,
+          deviceModelType: this.store.device.modelId
+        }
+      });
+
+      const encPayload = this.noiseState.encryptWithAd(payload);
+      const finish     = encodeHandshakeClientFinish(encStatic, encPayload);
+      this.socket.write(makeFrame(finish));
+
+      const keys        = this.noiseState.split();
+      this.writeKey     = keys.writeKey;
+      this.readKey      = keys.readKey;
+      this.writeCounter = 0;
+      this.readCounter  = 0;
+      this.secured      = true;
+
+      // Wait for the server's <success> or <failure> confirmation before
+      // declaring the channel open. _processBuffer() will call
+      // _handleSecuredFrame() for the next frame, which handles auth.
+      this._awaitingAuth = true;
+
+    } catch (err) {
+      if (this._connectReject) {
+        this._connectReject(err);
+        this._connectResolve = null;
+        this._connectReject  = null;
+      }
+      this.emit('error', err);
+    }
+  }
+
+  _handleSecuredFrame(frame) {
+    try {
+      const plain = aesgcmDecrypt(this.readKey, this.readCounter++, frame, null);
+      const { decodeNode } = require('./BinaryNode');
+      const node  = decodeNode(plain);
+
+      // ── Auth confirmation from server ─────────────────────────────────────
+      // The very first secured frame must be <success> or <failure>.
+      // Only after <success> do we resolve the connect() promise and emit 'open'.
+      if (this._awaitingAuth) {
+        this._awaitingAuth = false;
+        const tag = node && node.description;
+
+        if (tag === 'success') {
+          if (this._connectResolve) {
+            this._connectResolve();
+            this._connectResolve = null;
+            this._connectReject  = null;
+          }
+          // Pass the full success node so Client can extract ADV identity,
+          // platform, expiration, and other server-provided account info.
+          this.emit('open', node);
+          return;
+        }
+
+        if (tag === 'failure') {
+          const attrs  = (node && node.attrs) || {};
+          const reason = attrs.reason || attrs.location || '401';
+          const err    = new Error('WhatsApp auth failure: ' + reason);
+          err.code     = reason;
+          if (this._connectReject) {
+            this._connectReject(err);
+            this._connectResolve = null;
+            this._connectReject  = null;
+          }
+          this.emit('error', err);
+          return;
+        }
+
+        // Unexpected first node — log it as an error but try to continue
+        const err = new Error('Unexpected first server node after handshake: ' + tag);
+        if (this._connectReject) {
+          this._connectReject(err);
+          this._connectResolve = null;
+          this._connectReject  = null;
+        }
+        this.emit('error', err);
+        return;
+      }
+      // ─────────────────────────────────────────────────────────────────────
+
+      this.emit('node', node);
+    } catch (err) {
+      this.emit('error', err);
+    }
+  }
+
+  sendNode(node) {
+    if (!this.secured) throw new Error('Channel not secured — handshake incomplete');
+    const { encodeNode } = require('./BinaryNode');
+    const plain      = encodeNode(node);
+    const ciphertext = aesgcmEncrypt(this.writeKey, this.writeCounter++, plain, null);
+    this.socket.write(makeFrame(ciphertext));
+  }
+
+  _onTcpError(err) {
+    if (this._connectReject) {
+      this._connectReject(err);
+      this._connectResolve = null;
+      this._connectReject  = null;
+    }
+    this.emit('error', err);
+  }
+
+  _onTcpClose() {
+    this.connected = false;
+    this.secured   = false;
+    this.emit('close');
+  }
+
+  close() {
+    if (this.socket) {
+      try { this.socket.destroy(); } catch (_) {}
+      this.socket = null;
+    }
+  }
+}
+
+module.exports = { NoiseSocket };

package/lib/proto/MessageProto.js

@@ -0,0 +1,229 @@
+'use strict';
+
+const WIRE_VARINT = 0;
+const WIRE_LEN    = 2;
+
+function tag(fieldNumber, wireType) {
+  return encodeVarint((fieldNumber << 3) | wireType);
+}
+
+function encodeVarint(n) {
+  const bytes = [];
+  let val = n >>> 0;
+  while (val > 127) {
+    bytes.push((val & 0x7f) | 0x80);
+    val = val >>> 7;
+  }
+  bytes.push(val);
+  return Buffer.from(bytes);
+}
+
+function encodeVarintSigned(n) {
+  if (n < 0) {
+    const big = BigInt(n);
+    const unsigned = big & 0xffffffffffffffffn;
+    const bytes = [];
+    let val = unsigned;
+    while (val > 127n) {
+      bytes.push(Number(val & 0x7fn) | 0x80);
+      val = val >> 7n;
+    }
+    bytes.push(Number(val));
+    return Buffer.from(bytes);
+  }
+  return encodeVarint(n);
+}
+
+function field(fieldNum, wireType, data) {
+  if (data === null || data === undefined) return Buffer.alloc(0);
+  const t = tag(fieldNum, wireType);
+  if (wireType === WIRE_VARINT) {
+    return Buffer.concat([t, data]);
+  }
+  const lenBuf = encodeVarint(data.length);
+  return Buffer.concat([t, lenBuf, data]);
+}
+
+function varint(n)   { return encodeVarint(n); }
+function varintS(n)  { return encodeVarintSigned(n); }
+function bytes(b)    { return b ? Buffer.from(b) : Buffer.alloc(0); }
+function str(s)      { return s ? Buffer.from(s, 'utf8') : Buffer.alloc(0); }
+function bool(b)     { return encodeVarint(b ? 1 : 0); }
+
+function encodeText(text, contextInfo) {
+  if (contextInfo) {
+    const inner = Buffer.concat([
+      field(1,  WIRE_LEN, str(text)),
+      field(17, WIRE_LEN, encodeContextInfo(contextInfo))
+    ]);
+    return field(38, WIRE_LEN, inner);
+  }
+  return field(1, WIRE_LEN, str(text));
+}
+
+function encodeContextInfo(ctx) {
+  const parts = [];
+  if (ctx.quotedMessageId)  parts.push(field(1, WIRE_LEN, str(ctx.quotedMessageId)));
+  if (ctx.participant)      parts.push(field(2, WIRE_LEN, str(ctx.participant)));
+  if (ctx.quotedMessage)    parts.push(field(3, WIRE_LEN, ctx.quotedMessage));
+  if (ctx.remoteJid)        parts.push(field(4, WIRE_LEN, str(ctx.remoteJid)));
+  return Buffer.concat(parts);
+}
+
+function encodeImageMessage(opts) {
+  const parts = [
+    field(1,  WIRE_LEN,    str(opts.url)),
+    field(2,  WIRE_LEN,    str(opts.mimetype || 'image/jpeg')),
+    field(3,  WIRE_LEN,    str(opts.caption  || '')),
+    field(4,  WIRE_LEN,    bytes(opts.fileSha256)),
+    field(5,  WIRE_VARINT, varint(opts.fileLength)),
+    field(6,  WIRE_VARINT, varint(opts.height  || 0)),
+    field(7,  WIRE_VARINT, varint(opts.width   || 0)),
+    field(8,  WIRE_LEN,    bytes(opts.mediaKey)),
+    field(9,  WIRE_LEN,    bytes(opts.fileEncSha256)),
+    field(11, WIRE_LEN,    str(opts.directPath)),
+    field(12, WIRE_VARINT, varintS(opts.mediaKeyTimestamp || Math.floor(Date.now() / 1000)))
+  ];
+  if (opts.jpegThumbnail) parts.push(field(16, WIRE_LEN, bytes(opts.jpegThumbnail)));
+  if (opts.contextInfo)   parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
+  return Buffer.concat(parts);
+}
+
+function encodeVideoMessage(opts) {
+  const parts = [
+    field(1,  WIRE_LEN,    str(opts.url)),
+    field(2,  WIRE_LEN,    str(opts.mimetype || 'video/mp4')),
+    field(3,  WIRE_LEN,    bytes(opts.fileSha256)),
+    field(4,  WIRE_VARINT, varint(opts.fileLength)),
+    field(5,  WIRE_VARINT, varint(opts.seconds || 0)),
+    field(6,  WIRE_LEN,    bytes(opts.mediaKey)),
+    field(7,  WIRE_LEN,    str(opts.caption || '')),
+    field(9,  WIRE_VARINT, varint(opts.height || 0)),
+    field(10, WIRE_VARINT, varint(opts.width  || 0)),
+    field(11, WIRE_LEN,    bytes(opts.fileEncSha256)),
+    field(12, WIRE_LEN,    str(opts.directPath)),
+    field(13, WIRE_VARINT, varintS(opts.mediaKeyTimestamp || Math.floor(Date.now() / 1000)))
+  ];
+  if (opts.jpegThumbnail) parts.push(field(16, WIRE_LEN, bytes(opts.jpegThumbnail)));
+  if (opts.gifPlayback)   parts.push(field(8,  WIRE_VARINT, bool(true)));
+  if (opts.contextInfo)   parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
+  return Buffer.concat(parts);
+}
+
+function encodeAudioMessage(opts) {
+  const parts = [
+    field(1,  WIRE_LEN,    str(opts.url)),
+    field(2,  WIRE_LEN,    str(opts.mimetype || 'audio/ogg; codecs=opus')),
+    field(3,  WIRE_LEN,    bytes(opts.fileSha256)),
+    field(4,  WIRE_VARINT, varint(opts.fileLength)),
+    field(5,  WIRE_VARINT, varint(opts.seconds || 0)),
+    field(6,  WIRE_VARINT, bool(opts.ptt || false)),
+    field(7,  WIRE_LEN,    bytes(opts.mediaKey)),
+    field(8,  WIRE_LEN,    bytes(opts.fileEncSha256)),
+    field(9,  WIRE_LEN,    str(opts.directPath)),
+    field(10, WIRE_VARINT, varintS(opts.mediaKeyTimestamp || Math.floor(Date.now() / 1000)))
+  ];
+  if (opts.contextInfo) parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
+  return Buffer.concat(parts);
+}
+
+function encodeDocumentMessage(opts) {
+  const parts = [
+    field(1,  WIRE_LEN,    str(opts.url)),
+    field(2,  WIRE_LEN,    str(opts.mimetype || 'application/octet-stream')),
+    field(3,  WIRE_LEN,    str(opts.title    || opts.fileName || 'file')),
+    field(4,  WIRE_LEN,    bytes(opts.fileSha256)),
+    field(5,  WIRE_VARINT, varint(opts.fileLength)),
+    field(7,  WIRE_LEN,    bytes(opts.mediaKey)),
+    field(8,  WIRE_LEN,    str(opts.fileName || 'file')),
+    field(9,  WIRE_LEN,    bytes(opts.fileEncSha256)),
+    field(10, WIRE_LEN,    str(opts.directPath)),
+    field(11, WIRE_VARINT, varintS(opts.mediaKeyTimestamp || Math.floor(Date.now() / 1000)))
+  ];
+  if (opts.jpegThumbnail) parts.push(field(16, WIRE_LEN, bytes(opts.jpegThumbnail)));
+  if (opts.contextInfo)   parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
+  return Buffer.concat(parts);
+}
+
+function encodeStickerMessage(opts) {
+  const parts = [
+    field(1,  WIRE_LEN,    str(opts.url)),
+    field(2,  WIRE_LEN,    bytes(opts.fileSha256)),
+    field(3,  WIRE_LEN,    bytes(opts.fileEncSha256)),
+    field(4,  WIRE_LEN,    bytes(opts.mediaKey)),
+    field(5,  WIRE_LEN,    str(opts.mimetype || 'image/webp')),
+    field(6,  WIRE_VARINT, varint(opts.height || 512)),
+    field(7,  WIRE_VARINT, varint(opts.width  || 512)),
+    field(8,  WIRE_LEN,    str(opts.directPath)),
+    field(9,  WIRE_VARINT, varint(opts.fileLength)),
+    field(10, WIRE_VARINT, varintS(opts.mediaKeyTimestamp || Math.floor(Date.now() / 1000)))
+  ];
+  if (opts.isAnimated)  parts.push(field(13, WIRE_VARINT, bool(true)));
+  if (opts.contextInfo) parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
+  return Buffer.concat(parts);
+}
+
+function encodeReactionMessage(opts) {
+  const parts = [
+    field(1, WIRE_LEN,    encodeMessageKey(opts.key)),
+    field(2, WIRE_LEN,    str(opts.text || '')),
+    field(4, WIRE_VARINT, varintS(opts.senderTimestampMs || Date.now()))
+  ];
+  return Buffer.concat(parts);
+}
+
+function encodeMessageKey(key) {
+  return Buffer.concat([
+    field(1, WIRE_LEN, str(key.remoteJid)),
+    field(2, WIRE_VARINT, bool(key.fromMe || false)),
+    field(3, WIRE_LEN, str(key.id))
+  ]);
+}
+
+function encodeMessage(type, payload) {
+  switch (type) {
+    case 'text':     return payload;
+    case 'image':    return field(3,  WIRE_LEN, payload);
+    case 'document': return field(7,  WIRE_LEN, payload);
+    case 'audio':    return field(8,  WIRE_LEN, payload);
+    case 'video':    return field(9,  WIRE_LEN, payload);
+    case 'sticker':  return field(26, WIRE_LEN, payload);
+    case 'reaction': return field(46, WIRE_LEN, payload);
+    default:         return payload;
+  }
+}
+
+// ─── DeviceSentMessage wrapper (field 31 of Message) ─────────────────────────
+// Used when sending to own linked devices — wraps the original message so other
+// devices know where the message was originally addressed (destinationJid).
+// DeviceSentMessage { destinationJid=1, message=2, phash=3 }
+
+function encodeDeviceSentMessage(destinationJid, messageBuf, phash) {
+  const inner = Buffer.concat([
+    field(1, WIRE_LEN, str(destinationJid)),
+    field(2, WIRE_LEN, messageBuf),
+    phash ? field(3, WIRE_LEN, str(phash)) : Buffer.alloc(0)
+  ]);
+  return field(31, WIRE_LEN, inner);
+}
+
+module.exports = {
+  encodeText,
+  encodeImageMessage,
+  encodeVideoMessage,
+  encodeAudioMessage,
+  encodeDocumentMessage,
+  encodeStickerMessage,
+  encodeReactionMessage,
+  encodeMessageKey,
+  encodeMessage,
+  encodeDeviceSentMessage,
+  encodeContextInfo,
+  encodeVarint,
+  field,
+  varint,
+  str,
+  bytes,
+  WIRE_VARINT,
+  WIRE_LEN
+};