kersiosocket 0.0.0-stage → 0.6.0-dev

package/test/pairing-adapter.test.js

@@ -0,0 +1,71 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { EventEmitter } = require('node:events')
+const { PairingLifecycle } = require('../src/pairing/lifecycle')
+const { attachQrPairingAdapter } = require('../src/pairing/adapter')
+
+function mockSocket(credentials) {
+  const ev = new EventEmitter()
+  ev._safeEmit = (event, ...args) => {
+    for (const listener of ev.rawListeners(event)) {
+      try { Reflect.apply(listener, ev, args) } catch { /* test helper isolates events */ }
+    }
+  }
+  return {
+    ev,
+    sessionId: 'fixture-session',
+    pairing: new PairingLifecycle({ sessionId: 'fixture-session' }),
+    protocol: {},
+    sentNodes: [],
+    sendNode(node) { this.sentNodes.push(node) },
+    credentials
+  }
+}
+
+test('QR adapter acknowledges pair-device and emits references from decoded node', async () => {
+  const creds = {
+    noiseKey: { public: Buffer.alloc(32, 1) },
+    signedIdentityKey: { public: Buffer.alloc(32, 2) },
+    advSecretKey: Buffer.alloc(32, 3)
+  }
+  const sock = mockSocket(creds)
+  const firstQr = new Promise((resolve) => sock.pairing.once('pairing.qr', resolve))
+  sock.pairing.begin('qr')
+  const detach = attachQrPairingAdapter(sock, { credentials: creds, clientType: '1', firstQrMs: 60000, nextQrMs: 20000 })
+  sock.ev.emit('node', {
+    tag: 'iq', attrs: { type: 'set', from: 'server@c.us', id: 'pair-1' },
+    content: [{ tag: 'pair-device', attrs: {}, content: [
+      { tag: 'ref', attrs: {}, content: Buffer.from('ref-fixture-1') },
+      { tag: 'ref', attrs: {}, content: Buffer.from('ref-fixture-2') }
+    ] }]
+  })
+  const qr = await firstQr
+  assert.match(qr.qr, /^https:\/\/wa\.me\/settings\/linked_devices#ref-fixture-1,/)
+  assert.equal(qr.sessionId, 'fixture-session')
+  assert.deepEqual(sock.sentNodes, [{ tag: 'iq', attrs: { to: 's.whatsapp.net', type: 'result', id: 'pair-1' } }])
+  detach()
+  sock.pairing.close()
+})
+
+test('QR adapter does not invent keys and never marks pair-success verified', async () => {
+  const sock = mockSocket(undefined)
+  const errors = []
+  let candidate
+  sock.pairing.on('pairing.error', (event) => errors.push(event.error.message))
+  sock.ev.on('pairing.success.candidate', (event) => { candidate = event })
+  sock.pairing.begin('qr')
+  const detach = attachQrPairingAdapter(sock, { credentials: undefined, clientType: '1' })
+  sock.ev.emit('node', {
+    tag: 'iq', attrs: { type: 'set', from: 's.whatsapp.net', id: 'pair-2' },
+    content: [{ tag: 'pair-device', attrs: {}, content: [{ tag: 'ref', attrs: {}, content: Buffer.from('ref') }] }]
+  })
+  await new Promise((resolve) => setImmediate(resolve))
+  assert.ok(errors.length >= 1)
+  assert.match(errors[0], /kunci|key|credential|bytes/i)
+  sock.ev.emit('node', { tag: 'iq', attrs: { type: 'set', from: 's.whatsapp.net', id: 'pair-3' }, content: [{ tag: 'pair-success', attrs: {}, content: [] }] })
+  assert.ok(candidate)
+  assert.notEqual(sock.pairing.state, 'paired')
+  detach()
+  sock.pairing.close()
+})

package/test/pairing.test.js

@@ -0,0 +1,32 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { PairingLifecycle } = require('../src')
+
+test('PairingLifecycle QR: update -> QR -> paired, terisolasi per session', () => {
+  const a = new PairingLifecycle({ sessionId: 'nomor-a' })
+  const b = new PairingLifecycle({ sessionId: 'nomor-b' })
+  const updates = [], qrs = [], success = []
+  a.on('pairing.update', (e) => updates.push(e.state))
+  a.on('pairing.qr', (e) => qrs.push(e.qr))
+  a.on('pairing.success', (e) => success.push(e.sessionId))
+  a.begin('qr').acceptQr('test-only-qr-payload').complete({ registered: true })
+  assert.deepEqual(updates, ['waiting-qr', 'paired'])
+  assert.deepEqual(qrs, ['test-only-qr-payload'])
+  assert.deepEqual(success, ['nomor-a'])
+  assert.equal(b.state, 'idle')
+})
+
+test('PairingLifecycle code: validasi transisi dan invalidasi state setelah close', () => {
+  const flow = new PairingLifecycle({ sessionId: 'nomor-c' })
+  let code = null
+  flow.on('pairing.code', (e) => { code = e.code })
+  flow.begin('code').acceptCode('AB12-CD34')
+  assert.equal(code, 'AB12-CD34')
+  assert.throws(() => flow.acceptQr('qr'), /QR tidak diharapkan/)
+  flow.fail(new Error('contoh gagal'))
+  assert.equal(flow.state, 'failed')
+  flow.reset().close()
+  assert.equal(flow.state, 'closed')
+  assert.throws(() => flow.begin('qr'), /ditutup/)
+})

package/test/proto.test.js

@@ -0,0 +1,64 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { encodeVarint, fieldVarint, fieldBool, fieldString, fieldBytes, fieldFixed32, pack, parseFields } = require('../src/proto/wire')
+const { encodeClientPayload, PLATFORM, CONNECT_REASON } = require('../src/proto/client-payload')
+
+const userAgent = {
+  platform: 'WEB', appVersion: [2, 3000, 1040000000],
+  releaseChannel: 'RELEASE', localeLanguage: 'id', localeCountry: 'ID'
+}
+const webInfo = { version: 'test-version-only', webSubPlatform: 'WEB_BROWSER' }
+const registration = {
+  mode: 'registration', passive: false, pushName: 'Kersio test', userAgent, webInfo,
+  connectReason: 'USER_ACTIVATED', connectType: 'WIFI_UNKNOWN', connectAttemptCount: 0,
+  devicePairingData: {
+    eRegid: Buffer.from([0, 0, 0, 1]), eKeytype: Buffer.from([5]), eIdent: Buffer.alloc(32, 1),
+    eSkeyId: Buffer.from([0, 0, 1]), eSkeyVal: Buffer.alloc(32, 2), eSkeySig: Buffer.alloc(64, 3),
+    buildHash: Buffer.alloc(16, 4), deviceProps: Buffer.from([0x0a, 0x01, 0x78])
+  }
+}
+
+test('protobuf wire: varint, string, bool, bytes, sfixed32 round-trip ke entri wire', () => {
+  const payload = pack([
+    fieldVarint(1, 300), fieldBool(2, false), fieldString(3, 'kersio'),
+    fieldBytes(4, Buffer.from([1, 2, 3])), fieldFixed32(5, -42)
+  ])
+  const f = parseFields(payload)
+  assert.deepEqual(f.map((x) => [x.fieldNumber, x.wireType]), [[1, 0], [2, 0], [3, 2], [4, 2], [5, 5]])
+  assert.equal(f[0].value, 300n)
+  assert.equal(f[1].value, 0n)
+  assert.equal(f[2].value.toString(), 'kersio')
+  assert.deepEqual(f[3].value, Buffer.from([1, 2, 3]))
+  assert.equal(f[4].value.readInt32LE(), -42)
+  assert.deepEqual(encodeVarint(0), Buffer.from([0]))
+})
+
+test('ClientPayload registration: membuat bytes berisi field utama dan DevicePairingRegistrationData', () => {
+  const out = encodeClientPayload(registration)
+  assert.ok(out.length > 100)
+  const fields = parseFields(out)
+  assert.ok(fields.some((f) => f.fieldNumber === 3 && f.wireType === 0 && f.value === 0n))
+  assert.ok(fields.some((f) => f.fieldNumber === 5 && f.wireType === 2))
+  assert.ok(fields.some((f) => f.fieldNumber === 6 && f.wireType === 2))
+  assert.ok(fields.some((f) => f.fieldNumber === 19 && f.wireType === 2))
+  assert.equal(PLATFORM.WEB, 14)
+  assert.equal(CONNECT_REASON.USER_ACTIVATED, 1)
+})
+
+test('ClientPayload login: username harus nomor digit dan tanpa pairing registration data', () => {
+  const out = encodeClientPayload({ mode: 'login', username: '6281234567890', userAgent, webInfo, passive: false })
+  const first = parseFields(out)[0]
+  assert.equal(first.fieldNumber, 1)
+  assert.equal(first.value, 6281234567890n)
+  assert.throws(() => encodeClientPayload({ mode: 'login', username: '+6281234567890', userAgent, webInfo }), /digit nomor/)
+  assert.throws(() => encodeClientPayload({ mode: 'registration', userAgent, webInfo }), /devicePairingData lengkap/)
+})
+
+test('ClientPayload: memvalidasi ukuran kunci dan schema wajib', () => {
+  const bad = structuredClone(registration)
+  bad.devicePairingData.eSkeySig = Buffer.alloc(32)
+  assert.throws(() => encodeClientPayload(bad), /eSkeySig harus 64 byte/)
+  assert.throws(() => encodeClientPayload({ mode: 'login', username: '6281234567890', webInfo }), /userAgent wajib diisi/)
+  assert.throws(() => parseFields(Buffer.from([0x0a, 0x05, 0x01])), /panjang field melebihi buffer/)
+})

package/test/session-manager.test.js

@@ -0,0 +1,34 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { EventEmitter } = require('node:events')
+const { KersioSessionManager } = require('../src/client/session-manager')
+const { KersioClient } = require('../src/client/kersio-client')
+
+class StubBackend extends EventEmitter {
+  constructor(engine) { super(); this.engine = engine; this.closed = false }
+  async connect() { this.emit('connection.update', { connection: 'open' }) }
+  async sendMessage(jid, content) { return { jid, content } }
+  async close() { this.closed = true }
+  capabilities() { return { engine: this.engine, live: false, messaging: true } }
+}
+
+test('session manager keeps independent sessions on different engines and closes them', async () => {
+  const made = []
+  const manager = new KersioSessionManager({ clientFactory: async ({ engine, sessionId }) => {
+    const backend = new StubBackend(engine)
+    made.push(backend)
+    return new KersioClient(backend, { sessionId })
+  } })
+  const zapo = await manager.open('acc-a', { engine: 'zapo' })
+  const baileys = await manager.open('acc-b', { engine: 'baileys' })
+  assert.equal(zapo.engine, 'zapo')
+  assert.equal(baileys.engine, 'baileys')
+  assert.equal(manager.stats().open, 2)
+  assert.equal(manager.get('acc-a'), zapo)
+  await assert.rejects(() => manager.open('acc-a', { engine: 'zapo' }), /sudah dibuka/)
+  assert.equal(await manager.close('acc-a'), true)
+  await manager.closeAll()
+  assert.equal(made.every((backend) => backend.closed), true)
+  assert.equal(manager.stats().total, 0)
+})

package/test/session.test.js

@@ -0,0 +1,134 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const { MemoryStore, FileStore, SQLiteStore, RedisStore, MongoStore, LRUCache, createSessionManager, makeSocket } = require('../src')
+
+const tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'kersio-'))
+
+async function contract(store) {
+  assert.equal(await store.get('a:x'), undefined)
+  const v = { buf: Buffer.from([1, 2, 3]), big: 123456789012345678901234567890n, n: 5, s: 'é/:*.', nested: { u: new Uint8Array([9, 8]) } }
+  await store.set('a:x', v)
+  const r = await store.get('a:x')
+  assert.ok(Buffer.isBuffer(r.buf)); assert.deepEqual(r.buf, v.buf)
+  assert.equal(r.big, v.big); assert.equal(r.n, 5); assert.equal(r.s, v.s)
+  assert.deepEqual([...r.nested.u], [9, 8])
+  await store.set('a:x', { n: 6 })
+  assert.equal((await store.get('a:x')).n, 6)
+  await store.set('b:y', 1)
+  assert.deepEqual((await store.keys('a:')).sort(), ['a:x'])
+  assert.deepEqual((await store.keys()).sort(), ['a:x', 'b:y'])
+  await store.delete('a:x')
+  assert.equal(await store.get('a:x'), undefined)
+}
+
+test('kontrak store: memory', () => contract(new MemoryStore()))
+test('kontrak store: file', () => contract(new FileStore(tmp())))
+test('kontrak store: sqlite', async () => { const s = new SQLiteStore(':memory:'); await contract(s); await s.close() })
+
+test('kontrak store: redis (klien palsu)', async () => {
+  const m = new Map()
+  const c = { get: async (k) => m.get(k) ?? null, set: async (k, v) => void m.set(k, v), del: async (k) => void m.delete(k),
+    keys: async (p) => [...m.keys()].filter((k) => k.startsWith(p.replace(/\\/g, '').slice(0, -1))) }
+  await contract(new RedisStore(c))
+})
+
+test('kontrak store: mongo (collection palsu)', async () => {
+  const m = new Map()
+  const col = {
+    findOne: async ({ _id }) => m.get(_id) ?? null,
+    replaceOne: async ({ _id }, doc) => void m.set(_id, doc),
+    deleteOne: async ({ _id }) => void m.delete(_id),
+    find: ({ _id: { $regex } }) => ({ toArray: async () => [...m.values()].filter((d) => new RegExp($regex).test(d._id)) })
+  }
+  await contract(new MongoStore(col))
+})
+
+test('FileStore: tulis atomik, tulis berurutan, tmp dibersihkan, file rusak dikarantina', async () => {
+  const dir = tmp()
+  fs.writeFileSync(path.join(dir, 'sisa.json.1.abcd.tmp'), 'setengah')
+  const s = new FileStore(dir)
+  assert.equal(fs.readdirSync(dir).some((f) => f.endsWith('.tmp')), false)
+
+  await Promise.all(Array.from({ length: 50 }, (_, i) => s.set('k', { i })))
+  assert.equal((await s.get('k')).i, 49) // urutan terjaga
+  assert.deepEqual(fs.readdirSync(dir).filter((f) => f.endsWith('.tmp')), [])
+
+  fs.writeFileSync(path.join(dir, 'rusak.json'), '{"setengah":')
+  assert.equal(await s.get('rusak'), undefined)
+  assert.ok(fs.readdirSync(dir).some((f) => f.startsWith('rusak.json.') && f.endsWith('.corrupt')))
+})
+
+test('FileStore: kegagalan rename tidak merusak file lama', async () => {
+  const dir = tmp()
+  const s = new FileStore(dir)
+  await s.set('k', { v: 'lama' })
+  const orig = fs.promises.rename
+  fs.promises.rename = async () => { throw new Error('mati di tengah') }
+  try { await assert.rejects(s.set('k', { v: 'baru' }), /mati di tengah/) } finally { fs.promises.rename = orig }
+  assert.equal((await s.get('k')).v, 'lama')
+  assert.deepEqual(fs.readdirSync(dir).filter((f) => f.endsWith('.tmp')), [])
+})
+
+test('makeSocket + store: kunci dibuat sekali lalu dipakai ulang antar restart', async () => {
+  const store = new FileStore(tmp())
+  const a = makeSocket({ store, sessionId: 'nomor-a', autoConnect: false })
+  await a.ready
+  const k1 = a.creds.staticKey.public
+  const b = makeSocket({ store, sessionId: 'nomor-a', autoConnect: false })
+  await b.ready
+  assert.deepEqual(b.creds.staticKey.public, k1)
+  assert.ok(Buffer.isBuffer(b.creds.staticKey.private))
+  const c = makeSocket({ store, sessionId: 'nomor-b', autoConnect: false })
+  await c.ready
+  assert.notDeepEqual(c.creds.staticKey.public, k1)
+})
+
+test('SessionManager: banyak sesi, list, close + purge', async () => {
+  const store = new MemoryStore()
+  const mgr = createSessionManager({ store, autoConnect: false })
+  const a = mgr.open('a'), b = mgr.open('b')
+  assert.equal(mgr.open('a'), a)
+  await Promise.all([a.ready, b.ready])
+  assert.deepEqual((await mgr.list()).sort(), ['a', 'b'])
+  assert.equal(Object.keys(mgr.stats().sessions).length, 2)
+  await mgr.close('a', { purge: true })
+  assert.deepEqual(await mgr.list(), ['b'])
+  assert.throws(() => mgr.open('x:y'), /tidak valid/)
+  await mgr.closeAll()
+})
+
+test('LRUCache: batas entri, batas byte, TTL, urutan pakai', async () => {
+  const evicted = []
+  const c = new LRUCache({ max: 2, onEvict: (k, v, why) => evicted.push([k, why]) })
+  c.set('a', 1).set('b', 2); c.get('a'); c.set('c', 3)
+  assert.equal(c.has('b'), false); assert.equal(c.get('a'), 1)
+  assert.deepEqual(evicted, [['b', 'evicted']])
+
+  const m = new LRUCache({ max: 100, maxBytes: 10, sizeOf: (v) => v.length })
+  m.set('x', Buffer.alloc(6)); m.set('y', Buffer.alloc(6))
+  assert.equal(m.has('x'), false); assert.equal(m.bytes, 6)
+  m.set('gede', Buffer.alloc(50)) // entri tunggal raksasa tidak membuat cache kosong total
+  assert.equal(m.size, 1)
+
+  const t = new LRUCache({ ttl: 10 })
+  t.set('k', 1)
+  await new Promise((r) => setTimeout(r, 25))
+  assert.equal(t.get('k'), undefined)
+  assert.ok(c.stats().hitRate > 0)
+})
+
+test('multi-session: pairing lifecycle dan state tiap socket terisolasi', async () => {
+  const mgr = createSessionManager({ store: new MemoryStore(), autoConnect: false })
+  const a = mgr.open('nomor-a')
+  const b = mgr.open('nomor-b')
+  await Promise.all([a.ready, b.ready])
+  assert.notEqual(a.pairing, b.pairing)
+  a.pairing.begin('qr')
+  assert.equal(a.pairing.state, 'waiting-qr')
+  assert.equal(b.pairing.state, 'idle')
+  await mgr.closeAll()
+})

package/test/token-source.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { parseGoTokenTable, validateTokenTable } = require('../src/wabinary/token-source')
+
+const fixture = String.raw`package token
+var (
+  SingleByteTokens = [...]string{"", "iq", "quoted\\\"token", "line\\nfeed", "hex\\x41"}
+  DoubleByteTokens = [...][]string{
+    {"first", "second"},
+    {"third"},
+    {},
+    {"fourth"},
+  }
+)
+const DictVersion = 7
+`
+
+test('Go token-data parser reads string escapes and page boundaries', () => {
+  const parsed = parseGoTokenTable(fixture)
+  assert.equal(parsed.dictVersion, 7)
+  assert.deepEqual(parsed.single, ['', 'iq', 'quoted\\"token', 'line\\nfeed', 'hex\\x41'])
+  assert.deepEqual(parsed.double, [['first', 'second'], ['third'], [], ['fourth']])
+})
+
+test('token-data validator rejects the wrong dictionary version', () => {
+  const table = { dictVersion: 2, single: Array(236).fill('x'), double: Array.from({ length: 4 }, () => Array(256).fill('x')) }
+  table.single[0] = ''
+  assert.throws(() => validateTokenTable(table, { dictVersion: 3 }), /DictVersion mismatch/)
+})
+
+test('token-data validator requires exact versioned table dimensions', () => {
+  assert.throws(() => validateTokenTable({ dictVersion: 3, single: [], double: [[], [], [], []] }), /single-byte token table shape unexpected/)
+})

package/test/unified-client.test.js

@@ -0,0 +1,63 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { EventEmitter } = require('node:events')
+const { createKersioClient, KersioClient } = require('../src/client/kersio-client')
+const { BackendNotSupportedError } = require('../src/backends/base')
+
+class FakeBackend extends EventEmitter {
+  constructor() { super(); this.engine = 'fake'; this.sent = []; this.connected = false; this.closed = false }
+  async connect() { this.connected = true; this.emit('connection.update', { connection: 'open' }) }
+  async sendMessage(jid, content, options) { this.sent.push({ jid, content, options }); return { key: { id: `m${this.sent.length}` } } }
+  async close() { this.closed = true }
+  capabilities() { return { engine: this.engine, live: true, messaging: true, media: true, groups: false, historySync: false } }
+}
+
+test('unified client normalizes text/media/reaction API and validates user input', async () => {
+  const backend = new FakeBackend()
+  const client = new KersioClient(backend)
+  await client.connect()
+  await client.sendText('123@s.whatsapp.net', 'halo')
+  await client.sendImage('123@s.whatsapp.net', Buffer.from('image'), { caption: 'foto' })
+  await client.react('123@s.whatsapp.net', { id: 'old', remoteJid: '123@s.whatsapp.net' }, '👍')
+  assert.deepEqual(backend.sent[0].content, { text: 'halo' })
+  assert.equal(backend.sent[1].content.caption, 'foto')
+  assert.equal(backend.sent[2].content.react.text, '👍')
+  await assert.rejects(() => client.sendText('', 'x'), /jid/)
+  await assert.rejects(() => client.sendImage('123@s.whatsapp.net', null), /wajib diisi/)
+  await client.close()
+  assert.equal(backend.closed, true)
+})
+
+test('connect() tidak menganggap koneksi berhasil hanya dari Promise resolve', async () => {
+  class NotReadyBackend extends FakeBackend { async connect() {} }
+  const client = new KersioClient(new NotReadyBackend())
+  await client.connect()
+  assert.equal(client.state, 'connecting')
+  await assert.rejects(() => client.sendText('123@s.whatsapp.net', 'belum siap'), /belum open/)
+  await client.close()
+})
+
+test('backend QR event yang sudah terjadi direplay ketika facade terpasang', async () => {
+  class ReplayBackend extends FakeBackend {
+    constructor() { super(); this.last = new Map([['pairing.qr', { qr: 'candidate' }]]) }
+    replay(event, handler) { if (this.last.has(event)) handler(this.last.get(event)) }
+  }
+  const client = new KersioClient(new ReplayBackend())
+  const qr = []
+  client.on('pairing.qr', (v) => qr.push(v.qr))
+  await new Promise((resolve) => setImmediate(resolve))
+  assert.deepEqual(qr, ['candidate'])
+  await client.close()
+})
+
+test('factory menolak native sebagai message engine yang belum lengkap', async () => {
+  await assert.rejects(() => createKersioClient({ engine: 'native' }), /belum complete/)
+})
+
+test('feature yang tidak didukung menghasilkan error eksplisit, tidak mengembalikan sukses palsu', async () => {
+  const client = await createKersioClient({ backend: new FakeBackend() })
+  await client.connect()
+  await assert.rejects(() => client.downloadMedia({}), BackendNotSupportedError)
+  await client.close()
+})

package/test/verified-commit.test.js

@@ -0,0 +1,43 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { MemoryStore } = require('../src/session/stores')
+const { PairingLifecycle } = require('../src/pairing/lifecycle')
+const { commitVerifiedPairSuccess } = require('../src/pairing/verified-commit')
+
+test('pair success tidak dipersistenkan atau ditandai paired bila pemeriksaan gagal', async () => {
+  const store = new MemoryStore()
+  const lifecycle = new PairingLifecycle({ sessionId: 'secure-test' })
+  lifecycle.begin('qr')
+  await assert.rejects(() => commitVerifiedPairSuccess({
+    node: { tag: 'iq' },
+    verifyPairSuccess: async () => ({ verified: true, checks: { deviceIdentity: true, accountSignature: true, advHmac: false }, credentials: { me: 'x' }, replyNode: { tag: 'iq' } }),
+    store, lifecycle, sendNode: async () => {}
+  }), { code: 'ERR_PAIR_SUCCESS_UNVERIFIED' })
+  assert.equal(lifecycle.state, 'waiting-qr')
+  assert.equal(await store.get('auth:secure-test:credentials'), undefined)
+})
+
+test('pair success commit membutuhkan semua check + credentials, menyimpan lalu membalas sebelum paired', async () => {
+  const store = new MemoryStore()
+  const lifecycle = new PairingLifecycle({ sessionId: 'secure-test' })
+  lifecycle.begin('qr')
+  const steps = []
+  const result = await commitVerifiedPairSuccess({
+    node: { tag: 'iq' },
+    verifyPairSuccess: async () => ({
+      verified: true,
+      checks: { deviceIdentity: true, accountSignature: true, advHmac: true },
+      credentials: { me: '123@s.whatsapp.net' },
+      replyNode: { tag: 'iq', attrs: { type: 'set' }, content: [{ tag: 'pair-device-sign', attrs: {} }] }
+    }),
+    store: { set: async (key, value) => { steps.push('store'); return store.set(key, value) } },
+    lifecycle,
+    sendNode: async (node) => { steps.push('reply'); assert.equal(node.content[0].tag, 'pair-device-sign') }
+  })
+  steps.push('after')
+  assert.deepEqual(steps, ['store', 'reply', 'after'])
+  assert.equal(result.verified, true)
+  assert.equal(lifecycle.state, 'paired')
+  assert.deepEqual(await store.get('auth:secure-test:credentials'), { me: '123@s.whatsapp.net' })
+})

package/test/wabinary.test.js

@@ -0,0 +1,147 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const zlib = require('node:zlib')
+const { encodeBinaryNode, decodeBinaryNode, TAGS } = require('../src/wabinary/codec')
+const { buildPairingQrPayload, extractPairingRefs, LINKED_DEVICES_PREFIX } = require('../src/pairing/qr')
+
+const emptyTokens = { single: [], double: [[], [], [], []] }
+
+test('WABinary: round-trip node attrs, nested children, strings and binary content', () => {
+  const input = {
+    tag: 'iq', attrs: { id: '42', type: 'result', to: 's.whatsapp.net' },
+    content: [
+      { tag: 'pair-device', attrs: {}, content: [{ tag: 'ref', attrs: {}, content: Buffer.from([0x01, 0x02, 0xff]) }] },
+      { tag: 'success', attrs: { t: '123' } }
+    ]
+  }
+  const wire = encodeBinaryNode(input, { tokens: emptyTokens })
+  const out = decodeBinaryNode(wire, { tokens: emptyTokens })
+  assert.equal(out.tag, 'iq')
+  assert.equal(out.attrs.id, '42')
+  assert.equal(out.content[0].tag, 'pair-device')
+  assert.deepEqual(out.content[0].content[0].content, Buffer.from([1, 2, 255]))
+  assert.equal(out.content[1].tag, 'success')
+})
+
+test('WABinary: raw JID pair, injected single/double token dictionaries', () => {
+  const tokens = { single: [null, 'iq', 'to'], double: [['pair-device'], [], [], []] }
+  const node = { tag: 'iq', attrs: { to: '123@s.whatsapp.net' }, content: [{ tag: 'pair-device', attrs: {} }] }
+  const out = decodeBinaryNode(encodeBinaryNode(node, { tokens }), { tokens })
+  assert.equal(out.tag, 'iq')
+  assert.equal(out.attrs.to, '123@s.whatsapp.net')
+  assert.equal(out.content[0].tag, 'pair-device')
+})
+
+test('WABinary: compressed and uncompressed transport prefixes', () => {
+  const node = { tag: 'message', attrs: { id: 'x' }, content: Buffer.from('hello') }
+  const raw = encodeBinaryNode(node, { tokens: emptyTokens })
+  const plain = decodeBinaryNode(raw, { tokens: emptyTokens })
+  const body = raw[0] === 0 ? raw.subarray(1) : raw
+  const compressed = decodeBinaryNode(Buffer.concat([Buffer.from([2]), zlib.deflateSync(body)]), { tokens: emptyTokens })
+  for (const out of [plain, compressed]) {
+    assert.equal(out.tag, node.tag)
+    assert.equal(out.attrs.id, node.attrs.id)
+    assert.deepEqual(out.content, node.content)
+  }
+})
+
+test('WABinary: truncated/unknown token inputs fail closed', () => {
+  assert.throws(() => decodeBinaryNode(Buffer.from([TAGS.LIST_8]), { tokens: emptyTokens, decompress: false }), /terpotong/)
+  assert.throws(() => decodeBinaryNode(Buffer.from([TAGS.LIST_8, 1, 1]), { tokens: emptyTokens, decompress: false }), /token tunggal/)
+})
+
+
+
+test('WABinary default encoder emits protocol 0x00 prefix and a pinned golden byte sequence', () => {
+  const single = Array(236).fill('')
+  single[3] = 's.whatsapp.net'
+  single[4] = 'type'
+  single[8] = 'id'
+  single[17] = 'to'
+  single[25] = 'iq'
+  single[41] = 'get'
+  single[86] = 'ping'
+  const tokens = { single, double: [Array(256).fill(''), Array(256).fill(''), Array(256).fill(''), Array(256).fill('')] }
+  const node = { tag: 'iq', attrs: { id: 'kersio-local-test', type: 'get', to: 's.whatsapp.net' }, content: [{ tag: 'ping', attrs: {} }] }
+  const expected = '00f8081908fc116b657273696f2d6c6f63616c2d7465737404291103f801f80156'
+  const encoded = encodeBinaryNode(node, { tokens })
+  assert.equal(encoded.toString('hex'), expected)
+  const decoded = decodeBinaryNode(encoded, { tokens })
+  assert.equal(decoded.tag, node.tag)
+  assert.deepEqual({ ...decoded.attrs }, node.attrs)
+  assert.equal(decoded.content[0].tag, 'ping')
+})
+
+test('WABinary packs digit/hex strings and round-trips device JID formats', () => {
+  const tokens = { single: [], double: [[], [], [], []] }
+  for (const value of ['1234567890', '12-34.56', 'ABCDEF09', '12345:2@s.whatsapp.net', '12345:7@lid', 'user@g.us']) {
+    const input = { tag: 'node', attrs: { value } }
+    const wire = encodeBinaryNode(input, { tokens })
+    assert.equal(wire[0], 0x00)
+    const output = decodeBinaryNode(wire, { tokens })
+    assert.equal(output.attrs.value, value)
+  }
+  const packed = encodeBinaryNode({ tag: 'x', attrs: { v: '12345' } }, { tokens })
+  assert.ok(packed.includes(0xff)) // HEX_8 or NIBBLE_8 marker in encoded attributes
+})
+
+
+
+test('WABinary decodes FB_JID and INTEROP_JID marker fixtures', () => {
+  const rawString = (value) => {
+    const b = Buffer.from(value, 'utf8')
+    assert.ok(b.length < 256)
+    return Buffer.concat([Buffer.from([TAGS.BINARY_8, b.length]), b])
+  }
+  const wrapValue = (encodedValue) => Buffer.concat([
+    Buffer.from([0x00, TAGS.LIST_8, 3]), rawString('x'), rawString('jid'), encodedValue
+  ])
+  const fb = Buffer.concat([Buffer.from([TAGS.FB_JID]), rawString('alice'), Buffer.from([0x00, 0x02]), rawString('s.whatsapp.net')])
+  const fbNode = decodeBinaryNode(wrapValue(fb), { tokens: emptyTokens, requirePrefix: true })
+  assert.equal(fbNode.attrs.jid, 'alice:2@s.whatsapp.net')
+
+  const interop = Buffer.concat([Buffer.from([TAGS.INTEROP_JID]), rawString('user'), Buffer.from([0x00, 0x07, 0x00, 0x03]), rawString('interop.example')])
+  const interopNode = decodeBinaryNode(wrapValue(interop), { tokens: emptyTokens, requirePrefix: true })
+  assert.equal(interopNode.attrs.jid, '3-user:7@interop.example')
+})
+
+test('WABinary leaves lowercase hex-looking text as raw UTF-8 and normalizes AD_JID device zero', () => {
+  const tokens = { single: [], double: [[], [], [], []] }
+  const lower = { tag: 'x', attrs: { value: 'deadbeef' } }
+  const lowerBytes = encodeBinaryNode(lower, { tokens })
+  assert.deepEqual(decodeBinaryNode(lowerBytes, { tokens }).attrs.value, 'deadbeef')
+  const encoded = encodeBinaryNode({ tag: 'x', attrs: { jid: '123:0@s.whatsapp.net' } }, { tokens })
+  const decoded = decodeBinaryNode(encoded, { tokens })
+  assert.equal(decoded.attrs.jid, '123@s.whatsapp.net')
+})
+
+test('WABinary compression option emits 0x02 prefix and respects output limits', () => {
+  const tokens = { single: [], double: [[], [], [], []] }
+  const node = { tag: 'message', attrs: { id: 'a'.repeat(2000) }, content: Buffer.from('payload') }
+  const compressed = encodeBinaryNode(node, { tokens, compress: true })
+  assert.equal(compressed[0], 0x02)
+  const decoded = decodeBinaryNode(compressed, { tokens })
+  assert.equal(decoded.tag, node.tag)
+  assert.equal(decoded.attrs.id, node.attrs.id)
+  assert.deepEqual(decoded.content, node.content)
+  assert.throws(() => encodeBinaryNode(node, { tokens, limits: { maxBytes: 100 } }), /maxBytes/)
+})
+
+test('pairing QR helper formats the observed fields and extracts pair-device refs', () => {
+  const payload = buildPairingQrPayload({
+    ref: Buffer.from('ref-1'), noisePublicKey: Buffer.alloc(32, 1),
+    identityPublicKey: Buffer.alloc(32, 2), advSecretKey: Buffer.alloc(32, 3), clientType: '1'
+  })
+  assert.ok(payload.startsWith(LINKED_DEVICES_PREFIX + 'ref-1,'))
+  const refs = extractPairingRefs({ tag: 'iq', attrs: {}, content: [{ tag: 'pair-device', attrs: {}, content: [
+    { tag: 'ref', attrs: {}, content: Buffer.from('ref-a') },
+    { tag: 'ref', attrs: {}, content: Buffer.from('ref-b') },
+    { tag: 'not-ref', attrs: {}, content: Buffer.from('ignore') }
+  ] }] })
+  assert.deepEqual(refs, [Buffer.from('ref-a'), Buffer.from('ref-b')])
+})
+
+test('pairing QR helper rejects incomplete key material', () => {
+  assert.throws(() => buildPairingQrPayload({ ref: 'ref', noisePublicKey: Buffer.alloc(31), identityPublicKey: Buffer.alloc(32), advSecretKey: Buffer.alloc(32), clientType: '1' }), /32 byte/)
+})