@zapo-js/fake-server 0.3.0 → 1.0.0

package/dist/esm/infra/WaFakeMediaHttpsServer.js

@@ -0,0 +1,126 @@
+/** HTTPS listener used by fake media upload/download flows. */
+import { createServer as createHttpsServer } from 'node:https';
+const FAKE_MEDIA_TLS_KEY_PEM = `-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC3xTRqB/wZbz/w
+pQgcOfCfizS0MrtVR0ulBa1vK4OlU1FXJNC0dtTKLs/jMWNqwYWXxSoGEHHfhUIS
+PgZ08nauCJs83ZFAQC1Es1sN1R32YokPmKOCTHHh8f5/uX3h5oUD/xr3gwOVs4c2
+ISmk1OTmp77KolxZXHOnlnHweO6DK0CqfT+53RzKj5rz4d7inyMk5ctk+JjHZd8e
+q46e4MH4ZWPM+ehwRwgWMQ2E1bFjVQsBMvtAkUxOEx+B2/Cys6jEUFo/ABkQxXt+
+InqWnYKHbPOToKmpPxDjT54OpVZs4IRtbkTrgEMMz3/c5g4XamGUHLqkI0GBESK2
+16STZettAgMBAAECggEAAr6CDGOfMMzRkdyeWyKosPKMIGbY+wNiSSbsabim4BO3
+LkLQgSK1d3fF3+KrDj6/DUJUti2/oZEKGoKwUn6T14BmV+7qvjX1WN8kqNsGYLXP
+XFB0jinpkf6XhPKUn7olCGdwglgR28XknLBXsmG6eMK5ODgiZi0Zqng9WPCSP3Aa
+5q7iSeJF0FsbQ1OdQT3t98WhnSN9t0TzLyNUqXWDBDIrrtT3O7B7theS+3LRhodE
+VFROogp4hfo6pBNweki08uFD250OP6iGpYsE0xY6NIfyebGS2iBmbDKQmMkWLdf0
+mSlvYoksnDan4tJMiXAbb39wLdJEa+x98Qzxq0iJyQKBgQDeBQSgVd7j99W0bdzo
+fnDgnjJS606UrWID/RyTEIMfq5Jf2sM2vTJ2/w4X1JoUxxQCJbFmoJs9RXn52XUa
+3/GaUbr3akUVjMb93JlbWTQVoKipMM6HGCee4rj69qdsmA8iJrnloGFpymLThcfm
+xZB535vbG3DrYRM8MH/crDQH2QKBgQDT5YlXskOxx/iVxpko4uacIBqHnPGbCPnK
+LXMaa5vrjGgWNK0ajj+0MFdpEl+HXC7ZDISmSRKExrMDaWkjoXzXhxz1BmHVdN3O
+lOZY6gY+WeQUPn2sfqROBAV7B66LmRjbLdK9kwqrD3nhED6XWR+ZuXaH0dMQ2UMe
+T9E1ixr3tQKBgQChrYvR6taWsosYioy9bh5rJCjHg33E/YIMH41odzTVok7EqP1R
+5nNSfqhXqEXQbazfZ22Jq9mAxBBwZvBFcuFxHKWHuQa4C715buTqxcoNGeLY2qb7
+cBaiOL62W1pO1Wjn2MW1N5bYwD45hQmuvx5X8gOAirovXpDwWu0x2OFG+QKBgAxE
+U4kiJs0Z+IgjMSauzA7pxN9o9Iu3H07XBrzW0fX28OeoMQVCiumRit3oVGNvsL6b
+/OnrfQj2v9JIve90H9gSWFjO/8bttxGIiTVIhwgBCDUr0Pa1dimWDgMrVK18NXYq
+1vJmms2AXdvrptP4Mt4hYH1IZmGpUjtk/4WMAgmpAoGAKJXzDPY5ll9Ebjz28u3W
+sPZdIz90rpRIBnyDC/AwtEzliU2PkuGpqe1ZJaP6cmPTxf/Bv8hfUMXknURpOShE
+Uusyt3/4dGRMY+XXKuTPMZA8sbIEatA2z2e6oBoyj9avzEKAwDsReuPyyX6BubTx
+rLSyj/PpCngrQw7YXsQc6Wc=
+-----END PRIVATE KEY-----
+`;
+const FAKE_MEDIA_TLS_CERT_PEM = `-----BEGIN CERTIFICATE-----
+MIIDGTCCAgGgAwIBAgIUCb8Qbq/uzK9W14G057lmny5p4kIwDQYJKoZIhvcNAQEL
+BQAwGzEZMBcGA1UEAwwQZmFrZS1tZWRpYS5sb2NhbDAgFw0yNjA0MDgyMjAzMDRa
+GA8yMTI2MDMxNTIyMDMwNFowGzEZMBcGA1UEAwwQZmFrZS1tZWRpYS5sb2NhbDCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALfFNGoH/BlvP/ClCBw58J+L
+NLQyu1VHS6UFrW8rg6VTUVck0LR21Mouz+MxY2rBhZfFKgYQcd+FQhI+BnTydq4I
+mzzdkUBALUSzWw3VHfZiiQ+Yo4JMceHx/n+5feHmhQP/GveDA5WzhzYhKaTU5Oan
+vsqiXFlcc6eWcfB47oMrQKp9P7ndHMqPmvPh3uKfIyTly2T4mMdl3x6rjp7gwfhl
+Y8z56HBHCBYxDYTVsWNVCwEy+0CRTE4TH4Hb8LKzqMRQWj8AGRDFe34iepadgods
+85Ogqak/EONPng6lVmzghG1uROuAQwzPf9zmDhdqYZQcuqQjQYERIrbXpJNl620C
+AwEAAaNTMFEwHQYDVR0OBBYEFG3DX82mLaatjTwwspHIj2pOD8CnMB8GA1UdIwQY
+MBaAFG3DX82mLaatjTwwspHIj2pOD8CnMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZI
+hvcNAQELBQADggEBAEqIu6mXgvSrGyQxRp6cJVg5OhBpwxH/V0IFe2H7xPBxreDS
+e9yb/ESLRFxpfeWhLXOBEsOGbrF8HvZ0zNTHW+MtIkJB/hhYVzDJyhEpf9jWvpaM
+H6CyzWIZgrXMmyeh0WkmVWoYyvlQrz9yJP63VfzCTCO6YBo02S+kKAyJiM9l8ZW5
+8vALhsyrGSMDnxQSixdc4L/Migam1LHxqwApzDvTdfXNiqjWEmfbw7sQKjd8EHad
+KxNzgzzCRBSkeLe9YoXxLkKRvYeBM/xiv0AVp/ABedHj0xj3ybvvdjowui1uCBip
+BoMF3OiuOeaTubj+tDzpZcauS4L+OyUPjsKqFoM=
+-----END CERTIFICATE-----
+`;
+export class WaFakeMediaHttpsServer {
+    constructor() {
+        this.server = null;
+        this.listenInfo = null;
+        this.requestHandler = null;
+    }
+    setRequestHandler(handler) {
+        this.requestHandler = handler;
+    }
+    async listen(host = '127.0.0.1', port = 0) {
+        if (this.server) {
+            throw new Error('fake media https server is already listening');
+        }
+        const server = createHttpsServer({
+            key: FAKE_MEDIA_TLS_KEY_PEM,
+            cert: FAKE_MEDIA_TLS_CERT_PEM
+        }, (req, res) => {
+            const handler = this.requestHandler;
+            if (!handler) {
+                res.statusCode = 404;
+                res.end();
+                return;
+            }
+            try {
+                const result = handler(req, res);
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        if (!res.headersSent) {
+                            res.statusCode = 500;
+                        }
+                        res.end(error instanceof Error ? error.message : String(error));
+                    });
+                }
+            }
+            catch (error) {
+                if (!res.headersSent) {
+                    res.statusCode = 500;
+                }
+                res.end(error instanceof Error ? error.message : String(error));
+            }
+        });
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                server.off('listening', onListening);
+                reject(error);
+            };
+            const onListening = () => {
+                server.off('error', onError);
+                resolve();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(port, host);
+        });
+        const address = server.address();
+        this.server = server;
+        this.listenInfo = { host: address.address, port: address.port };
+        return this.listenInfo;
+    }
+    async close() {
+        const server = this.server;
+        if (!server)
+            return;
+        await new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+        });
+        // Force any keep-alive sockets to close so the test process can exit.
+        server.closeAllConnections?.();
+        this.server = null;
+        this.listenInfo = null;
+    }
+    get info() {
+        return this.listenInfo;
+    }
+}

package/dist/esm/infra/WaFakeNoiseHandshake.js

@@ -0,0 +1,67 @@
+/** Responder-side Noise handshake primitives for fake server pipelines. */
+import { aesGcmDecrypt, aesGcmEncrypt, hkdfSplit, sha256 } from '../transport/crypto.js';
+const EMPTY = new Uint8Array(0);
+export class WaFakeNoiseHandshake {
+    constructor() {
+        this.hash = EMPTY;
+        this.chainingKey = EMPTY;
+        this.cipherKey = null;
+        this.nonceCounter = 0;
+    }
+    start(name, prologue) {
+        const initialHash = name.byteLength === 32 ? name : sha256(name);
+        this.hash = initialHash;
+        this.chainingKey = initialHash;
+        this.cipherKey = initialHash;
+        this.nonceCounter = 0;
+        this.authenticate(prologue);
+    }
+    authenticate(data) {
+        const concatenated = new Uint8Array(this.hash.byteLength + data.byteLength);
+        concatenated.set(this.hash, 0);
+        concatenated.set(data, this.hash.byteLength);
+        this.hash = sha256(concatenated);
+    }
+    mixIntoKey(input) {
+        const [nextChainingKey, nextCipherMaterial] = hkdfSplit(input, this.chainingKey, EMPTY);
+        this.chainingKey = nextChainingKey;
+        this.cipherKey = nextCipherMaterial;
+        this.nonceCounter = 0;
+    }
+    encrypt(plaintext) {
+        if (!this.cipherKey) {
+            throw new Error('noise handshake encrypt called before key was derived');
+        }
+        const iv = this.buildNonceIv();
+        this.nonceCounter += 1;
+        const ciphertext = aesGcmEncrypt(this.cipherKey, iv, plaintext, this.hash);
+        this.authenticate(ciphertext);
+        return ciphertext;
+    }
+    decrypt(ciphertext) {
+        if (!this.cipherKey) {
+            throw new Error('noise handshake decrypt called before key was derived');
+        }
+        const iv = this.buildNonceIv();
+        this.nonceCounter += 1;
+        const plaintext = aesGcmDecrypt(this.cipherKey, iv, ciphertext, this.hash);
+        this.authenticate(ciphertext);
+        return plaintext;
+    }
+    /** Derives transport keys (`first -> recv`, `second -> send` for responder role). */
+    finish() {
+        const [first, second] = hkdfSplit(EMPTY, this.chainingKey, EMPTY);
+        return {
+            recvKey: first,
+            sendKey: second,
+            recvKeyBytes: first,
+            sendKeyBytes: second
+        };
+    }
+    buildNonceIv() {
+        const iv = new Uint8Array(12);
+        const view = new DataView(iv.buffer);
+        view.setUint32(8, this.nonceCounter, false);
+        return iv;
+    }
+}

package/dist/esm/infra/WaFakeTransport.js

@@ -0,0 +1,31 @@
+/** Post-handshake Noise transport (AES-GCM with direction-specific counters). */
+import { aesGcmDecrypt, aesGcmEncrypt } from '../transport/crypto.js';
+export class WaFakeTransport {
+    constructor(keys) {
+        this.sendCounter = 0;
+        this.recvCounter = 0;
+        this.recvKey = keys.recvKey;
+        this.sendKey = keys.sendKey;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async encryptFrame(plaintext) {
+        const nonce = buildAesGcmNonce(this.sendCounter);
+        this.sendCounter += 1;
+        return aesGcmEncrypt(this.sendKey, nonce, plaintext);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async decryptFrame(ciphertext) {
+        const nonce = buildAesGcmNonce(this.recvCounter);
+        this.recvCounter += 1;
+        return aesGcmDecrypt(this.recvKey, nonce, ciphertext);
+    }
+}
+function buildAesGcmNonce(counter) {
+    if (counter > 0xffffffff) {
+        throw new Error('noise transport nonce counter overflow');
+    }
+    const nonce = new Uint8Array(12);
+    const view = new DataView(nonce.buffer);
+    view.setUint32(8, counter, false);
+    return nonce;
+}

package/dist/esm/infra/WaFakeWsServer.js

@@ -0,0 +1,96 @@
+import { createServer } from 'node:http';
+import { WebSocketServer } from 'ws';
+import { WaFakeConnection } from './WaFakeConnection.js';
+export class WaFakeWsServer {
+    constructor(options = {}) {
+        this.httpServer = null;
+        this.wsServer = null;
+        this.connectionListener = null;
+        this.httpRequestHandler = null;
+        this.nextConnectionId = 0;
+        this.options = {
+            host: options.host ?? '127.0.0.1',
+            port: options.port ?? 0,
+            path: options.path ?? '/ws/chat'
+        };
+    }
+    onConnection(listener) {
+        this.connectionListener = listener;
+    }
+    setHttpRequestHandler(handler) {
+        this.httpRequestHandler = handler;
+    }
+    async listen() {
+        if (this.httpServer) {
+            throw new Error('fake ws server is already listening');
+        }
+        const httpServer = createServer(async (req, res) => {
+            const handler = this.httpRequestHandler;
+            if (!handler) {
+                res.statusCode = 404;
+                res.end();
+                return;
+            }
+            try {
+                await Promise.resolve(handler(req, res)).catch((error) => {
+                    if (!res.headersSent) {
+                        res.statusCode = 500;
+                    }
+                    res.end(error instanceof Error ? error.message : String(error));
+                });
+            }
+            catch (error) {
+                if (!res.headersSent) {
+                    res.statusCode = 500;
+                }
+                res.end(error instanceof Error ? error.message : String(error));
+            }
+        });
+        const wsServer = new WebSocketServer({ server: httpServer, path: this.options.path });
+        wsServer.on('connection', (socket) => {
+            const id = `c${this.nextConnectionId++}`;
+            const connection = new WaFakeConnection(id, socket);
+            this.connectionListener?.(connection);
+        });
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                httpServer.off('listening', onListening);
+                reject(error);
+            };
+            const onListening = () => {
+                httpServer.off('error', onError);
+                resolve();
+            };
+            httpServer.once('error', onError);
+            httpServer.once('listening', onListening);
+            httpServer.listen(this.options.port, this.options.host);
+        });
+        this.httpServer = httpServer;
+        this.wsServer = wsServer;
+        const address = httpServer.address();
+        return {
+            host: address.address,
+            port: address.port,
+            path: this.options.path,
+            url: `ws://${address.address}:${address.port}${this.options.path}`
+        };
+    }
+    async close() {
+        const wsServer = this.wsServer;
+        const httpServer = this.httpServer;
+        if (!wsServer || !httpServer) {
+            return;
+        }
+        for (const client of wsServer.clients) {
+            client.terminate();
+        }
+        await new Promise((resolve, reject) => {
+            wsServer.close((error) => (error ? reject(error) : resolve()));
+        });
+        await new Promise((resolve, reject) => {
+            httpServer.close((error) => (error ? reject(error) : resolve()));
+        });
+        this.wsServer = null;
+        this.httpServer = null;
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/esm/protocol/auth/cert-chain.js

@@ -0,0 +1,39 @@
+/** Fake noise certificate chain generator for handshake tests. */
+import { X25519, xeddsaSign } from '../../transport/crypto.js';
+import { proto } from '../../transport/protos.js';
+export async function generateFakeNoiseRootCa() {
+    const keyPair = await X25519.generateKeyPair();
+    return {
+        publicKey: keyPair.pubKey,
+        privateKey: keyPair.privKey,
+        serial: 0
+    };
+}
+export async function buildFakeCertChain(input) {
+    const intermediateSerial = input.intermediateSerial ?? 1;
+    const leafSerial = input.leafSerial ?? 2;
+    const intermediateKeyPair = await X25519.generateKeyPair();
+    const intermediateDetails = proto.CertChain.NoiseCertificate.Details.encode({
+        serial: intermediateSerial,
+        issuerSerial: input.root.serial,
+        key: intermediateKeyPair.pubKey
+    }).finish();
+    const intermediateSignature = await xeddsaSign(input.root.privateKey, intermediateDetails);
+    const leafDetails = proto.CertChain.NoiseCertificate.Details.encode({
+        serial: leafSerial,
+        issuerSerial: intermediateSerial,
+        key: input.leafKey
+    }).finish();
+    const leafSignature = await xeddsaSign(intermediateKeyPair.privKey, leafDetails);
+    const encoded = proto.CertChain.encode({
+        intermediate: {
+            details: intermediateDetails,
+            signature: intermediateSignature
+        },
+        leaf: {
+            details: leafDetails,
+            signature: leafSignature
+        }
+    }).finish();
+    return { encoded };
+}

package/dist/esm/protocol/auth/client-payload-validate.js

@@ -0,0 +1,55 @@
+/** ClientPayload parser/validator (registration vs login flavors). */
+import { proto } from '../../transport/protos.js';
+export class ClientPayloadValidationError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'ClientPayloadValidationError';
+        this.code = code;
+    }
+}
+export function parseClientPayload(bytes) {
+    let raw;
+    try {
+        raw = proto.ClientPayload.decode(bytes);
+    }
+    catch (error) {
+        throw new ClientPayloadValidationError('invalid_proto', `failed to decode ClientPayload: ${error.message}`);
+    }
+    const devicePairingData = raw.devicePairingData;
+    if (devicePairingData) {
+        validateRegistrationFields(devicePairingData);
+        return {
+            kind: 'registration',
+            raw,
+            devicePairingData
+        };
+    }
+    if (raw.username === undefined || raw.username === null) {
+        throw new ClientPayloadValidationError('missing_username', 'login ClientPayload is missing the username field');
+    }
+    return {
+        kind: 'login',
+        raw,
+        username: String(raw.username),
+        device: typeof raw.device === 'number' ? raw.device : 0,
+        loginCounter: typeof raw.lc === 'number' ? raw.lc : 0
+    };
+}
+function validateRegistrationFields(devicePairingData) {
+    const required = [
+        ['eIdent', 'identity public key'],
+        ['eRegid', 'registration id'],
+        ['eKeytype', 'key type marker'],
+        ['eSkeyId', 'signed pre-key id'],
+        ['eSkeyVal', 'signed pre-key public'],
+        ['eSkeySig', 'signed pre-key signature'],
+        ['buildHash', 'client build hash'],
+        ['deviceProps', 'device properties']
+    ];
+    for (const [field, label] of required) {
+        const value = devicePairingData[field];
+        if (value === undefined || value === null) {
+            throw new ClientPayloadValidationError('missing_field', `registration ClientPayload missing ${label} (devicePairingData.${String(field)})`);
+        }
+    }
+}

package/dist/esm/protocol/auth/fake-primary-device.js

@@ -0,0 +1,47 @@
+/** Fake primary-device identity/signature helpers for pairing. */
+import { hmacSha256Sign, X25519, xeddsaSign } from '../../transport/crypto.js';
+import { proto } from '../../transport/protos.js';
+const ADV_PREFIX_ACCOUNT_SIGNATURE = new Uint8Array([0x06, 0x00]);
+export async function generateFakePrimaryDevice() {
+    return {
+        identityKeyPair: await X25519.generateKeyPair()
+    };
+}
+export async function buildAdvSignedDeviceIdentity(input) {
+    const advDeviceIdentity = proto.ADVDeviceIdentity.encode({
+        rawId: input.companionDeviceId,
+        timestamp: input.timestampSeconds ?? Math.floor(Date.now() / 1000),
+        keyIndex: input.keyIndex ?? 0
+    }).finish();
+    // Sign exactly: prefix || details || companionIdentityPublicKey.
+    const accountSignatureKey = input.primary.identityKeyPair.pubKey;
+    const messageToSign = concatBytes([
+        ADV_PREFIX_ACCOUNT_SIGNATURE,
+        advDeviceIdentity,
+        input.companionIdentityPublicKey
+    ]);
+    const accountSignature = await xeddsaSign(input.primary.identityKeyPair.privKey, messageToSign);
+    const signedIdentity = proto.ADVSignedDeviceIdentity.encode({
+        details: advDeviceIdentity,
+        accountSignatureKey,
+        accountSignature
+    }).finish();
+    const hmac = hmacSha256Sign(input.advSecretKey, signedIdentity);
+    const wrapped = proto.ADVSignedDeviceIdentityHMAC.encode({
+        details: signedIdentity,
+        hmac
+    }).finish();
+    return { deviceIdentityBytes: wrapped };
+}
+function concatBytes(parts) {
+    let total = 0;
+    for (const p of parts)
+        total += p.byteLength;
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+        out.set(p, offset);
+        offset += p.byteLength;
+    }
+    return out;
+}

package/dist/esm/protocol/auth/pair-device.js

@@ -0,0 +1,87 @@
+/** Pairing IQ builders/parsers (source: `WAWebHandlePairDevice*`, `/wa-web`). */
+import { decodeBase64Url } from '../../transport/util.js';
+export function buildPairDeviceIq(input) {
+    if (input.refs.length !== 6) {
+        throw new Error(`pair-device requires exactly 6 refs, got ${input.refs.length}`);
+    }
+    return {
+        tag: 'iq',
+        attrs: {
+            id: input.id ?? `pair-device-${Math.random().toString(36).slice(2, 10)}`,
+            type: 'set',
+            xmlns: 'md',
+            from: 's.whatsapp.net'
+        },
+        content: [
+            {
+                tag: 'pair-device',
+                attrs: {},
+                content: input.refs.map((ref) => ({
+                    tag: 'ref',
+                    attrs: {},
+                    content: ref
+                }))
+            }
+        ]
+    };
+}
+export function buildPairSuccessIq(input) {
+    const children = [
+        {
+            tag: 'device',
+            attrs: {
+                jid: input.deviceJid,
+                ...(input.deviceLid !== undefined ? { lid: input.deviceLid } : {})
+            }
+        },
+        {
+            tag: 'platform',
+            attrs: { name: input.platform }
+        },
+        {
+            tag: 'device-identity',
+            attrs: {},
+            content: input.deviceIdentityBytes
+        }
+    ];
+    if (input.bizName !== undefined) {
+        children.push({
+            tag: 'biz',
+            attrs: { name: input.bizName }
+        });
+    }
+    return {
+        tag: 'iq',
+        attrs: {
+            id: input.id ?? `pair-success-${Math.random().toString(36).slice(2, 10)}`,
+            type: 'set',
+            xmlns: 'md',
+            from: 's.whatsapp.net'
+        },
+        content: [
+            {
+                tag: 'pair-success',
+                attrs: {},
+                content: children
+            }
+        ]
+    };
+}
+export function parsePairingQrString(qr) {
+    const parts = qr.split(',');
+    if (parts.length < 5) {
+        throw new Error(`pairing qr must have 5 comma-separated parts, got ${parts.length}`);
+    }
+    const platform = parts[parts.length - 1];
+    const advSecretB64 = parts[parts.length - 2];
+    const identityPubB64 = parts[parts.length - 3];
+    const noisePubB64 = parts[parts.length - 4];
+    const ref = parts.slice(0, parts.length - 4).join(',');
+    return {
+        ref,
+        noisePublicKey: decodeBase64Url(noisePubB64, 'qr.noisePublicKey'),
+        identityPublicKey: decodeBase64Url(identityPubB64, 'qr.identityPublicKey'),
+        advSecretKey: decodeBase64Url(advSecretB64, 'qr.advSecretKey'),
+        platform
+    };
+}

package/dist/esm/protocol/auth/success-node.js

@@ -0,0 +1,26 @@
+/** Builder for the post-handshake `<success/>` stanza. */
+export function buildSuccessNode(input = {}) {
+    const t = input.t ?? Math.floor(Date.now() / 1000);
+    const props = input.props ?? 0;
+    const attrs = {
+        t: String(t),
+        props: String(props),
+        companion_enc_static: input.companionEncStatic ?? 'NULL'
+    };
+    if (input.lid !== undefined)
+        attrs.lid = input.lid;
+    if (input.displayName !== undefined)
+        attrs.display_name = input.displayName;
+    if (input.abprops !== undefined)
+        attrs.abprops = String(input.abprops);
+    if (input.groupAbprops !== undefined)
+        attrs.group_abprops = String(input.groupAbprops);
+    if (input.location !== undefined)
+        attrs.location = input.location;
+    if (input.creation !== undefined)
+        attrs.creation = String(input.creation);
+    return {
+        tag: 'success',
+        attrs
+    };
+}

package/dist/esm/protocol/iq/abprops.js

@@ -0,0 +1,30 @@
+/** Builds the `abt/props` IQ result consumed by the client ABProps parser. */
+import { buildIqResult } from './router.js';
+export function buildAbPropsResult(iq, input = {}) {
+    const result = buildIqResult(iq);
+    const propsAttrs = {
+        protocol: '1',
+        hash: input.hash ?? 'fake-abprops-hash',
+        refresh: String(input.refreshSeconds ?? 86400),
+        refresh_id: String(input.refreshId ?? 1),
+        delta_update: 'false'
+    };
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'props',
+                attrs: propsAttrs,
+                content: (input.props ?? []).map((prop) => ({
+                    tag: 'prop',
+                    attrs: {
+                        config_code: String(prop.configCode),
+                        ...(prop.configValue !== undefined
+                            ? { config_value: prop.configValue }
+                            : {})
+                    }
+                }))
+            }
+        ]
+    };
+}