Mobile connections

const client = new WaClient(
  {
    store,
    sessionId: 'mobile',
    mobileTransport: {
      deviceInfo: {
        manufacturer: 'OnePlus',
        device: 'OnePlus8Pro',
        osVersion: '12',
        osBuildNumber: 'SKQ1.210216.001',
        appVersion: '2.23.1.1',
        mcc: '55',  // mobile country code (optional)
        mnc: '11'   // mobile network code (optional)
      },
      passive: false // send keep-alives
    }
  },
  logger
)

await client.connect()

client.on('mobile_registration_code', (event) => {
  // WaRegistrationCodeEvent — someone requested a code to register YOUR number elsewhere
  console.log('registration code issued:', event.code, 'expires:', event.expiryTimestampMs)
})

client.on('mobile_account_takeover_notice', (event) => {
  // WaAccountTakeoverNoticeEvent — another device is taking over your number
  console.log('takeover attempt from', event.newDevicePlatform, event.newDeviceName)
})

// Current binding state
const status = await client.email.getStatus()
// { email: string | null, verified: boolean, confirmed: boolean }

// Bind an address, request a code, submit it, then confirm
await client.email.setEmail('me@example.com')
await client.email.requestVerificationCode({ /* BuildRequestEmailVerificationCodeInput */ })
const result = await client.email.verifyCode('123456')
// { verified, autoVerifyFailed, email }
await client.email.confirm()

import { createFileCompanionHostPersistence, WaClient } from 'zapo-js'

const client = new WaClient({
  store,
  sessionId: 'primary',
  mobileTransport: { deviceInfo: /* ... */ },
  companionHost: {
    persistence: createFileCompanionHostPersistence('./companion-host.json')
  }
}, logger)

interface CompanionHostPersistence {
  load(): CompanionHostEpochState | null | Promise<CompanionHostEpochState | null>
  save(state: CompanionHostEpochState): void | Promise<void>
}

interface CompanionHostEpochState {
  readonly rawId: number             // account's stable ADV identity id
  readonly currentKeyIndex: number   // last-issued key index; next companion gets +1
  readonly companions: readonly CompanionRecord[]
}

interface CompanionRecord {
  readonly deviceJid: string
  readonly keyIndex: number
  readonly companionIdentityPublicKey: Uint8Array
  readonly addedAtSeconds: number
}

import Database from 'better-sqlite3'
import type {
  CompanionHostEpochState,
  CompanionHostPersistence,
  CompanionRecord
} from 'zapo-js'

function createSqliteCompanionHostPersistence(
  db: Database.Database,
  sessionId: string
): CompanionHostPersistence {
  db.exec(`
    CREATE TABLE IF NOT EXISTS companion_host_epoch (
      session_id       TEXT PRIMARY KEY,
      raw_id           INTEGER NOT NULL,
      current_key_index INTEGER NOT NULL
    );
    CREATE TABLE IF NOT EXISTS companion_host_devices (
      session_id                     TEXT NOT NULL,
      device_jid                     TEXT NOT NULL,
      key_index                      INTEGER NOT NULL,
      companion_identity_public_key  BLOB NOT NULL,
      added_at_seconds               INTEGER NOT NULL,
      PRIMARY KEY (session_id, device_jid)
    );
  `)
  const readEpoch = db.prepare<[string]>(
    'SELECT raw_id AS rawId, current_key_index AS currentKeyIndex FROM companion_host_epoch WHERE session_id = ?'
  )
  const readDevices = db.prepare<[string]>(
    'SELECT device_jid AS deviceJid, key_index AS keyIndex, companion_identity_public_key AS pk, added_at_seconds AS addedAtSeconds FROM companion_host_devices WHERE session_id = ?'
  )
  const upsertEpoch = db.prepare(
    'INSERT INTO companion_host_epoch (session_id, raw_id, current_key_index) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET raw_id = excluded.raw_id, current_key_index = excluded.current_key_index'
  )
  const clearDevices = db.prepare('DELETE FROM companion_host_devices WHERE session_id = ?')
  const insertDevice = db.prepare(
    'INSERT INTO companion_host_devices (session_id, device_jid, key_index, companion_identity_public_key, added_at_seconds) VALUES (?, ?, ?, ?, ?)'
  )

  return {
    load(): CompanionHostEpochState | null {
      const header = readEpoch.get(sessionId) as { rawId: number; currentKeyIndex: number } | undefined
      if (!header) return null
      const rows = readDevices.all(sessionId) as Array<{
        deviceJid: string
        keyIndex: number
        pk: Buffer
        addedAtSeconds: number
      }>
      const companions: CompanionRecord[] = rows.map((row) => ({
        deviceJid: row.deviceJid,
        keyIndex: row.keyIndex,
        companionIdentityPublicKey: new Uint8Array(row.pk),
        addedAtSeconds: row.addedAtSeconds
      }))
      return { rawId: header.rawId, currentKeyIndex: header.currentKeyIndex, companions }
    },
    save(state: CompanionHostEpochState): void {
      db.transaction(() => {
        upsertEpoch.run(sessionId, state.rawId, state.currentKeyIndex)
        clearDevices.run(sessionId)
        for (const c of state.companions) {
          insertDevice.run(
            sessionId,
            c.deviceJid,
            c.keyIndex,
            Buffer.from(c.companionIdentityPublicKey),
            c.addedAtSeconds
          )
        }
      })()
    }
  }
}

import { WaClient } from 'zapo-js'

const client = new WaClient(
  { store, sessionId: 'primary', mobileTransport: { deviceInfo } },
  logger
)

client.on('companion_host_linked', ({ deviceJid, keyIndex }) => {
  console.log('linked companion', deviceJid, 'at key index', keyIndex)
})

client.on('companion_host_revoked', ({ deviceJid }) => {
  console.log('companion revoked:', deviceJid)
})

client.on('companion_host_error', (error) => {
  console.warn('companion-host operation failed', error.message)
})

await client.connect()

// Prompt for a WhatsApp Web QR string, then link:
const qr = await readCompanionQrFromSomewhere()
const { deviceJid } = await client.mobile.linkCompanion(qr)

// Later, list what's connected or revoke:
const companions = await client.mobile.listCompanions()
await client.mobile.revokeCompanion(deviceJid)