@zapo-js/fake-server 0.3.0 → 1.1.0

package/dist/infra/WaFakeConnection.d.ts

@@ -20,4 +20,3 @@ export declare class WaFakeConnection {
     close(code?: number, reason?: string): void;
     private bindSocketEvents;
 }
-//# sourceMappingURL=WaFakeConnection.d.ts.map

package/dist/infra/WaFakeConnection.js

@@ -51,4 +51,3 @@ class WaFakeConnection {
     }
 }
 exports.WaFakeConnection = WaFakeConnection;
-//# sourceMappingURL=WaFakeConnection.js.map

package/dist/infra/WaFakeConnectionPipeline.d.ts

@@ -2,7 +2,6 @@
 import { type FakeNoiseRootCa } from '../protocol/auth/cert-chain';
 import { type ParsedClientPayload } from '../protocol/auth/client-payload-validate';
 import { buildSuccessNode } from '../protocol/auth/success-node';
-import { type WaFakeIqRouter } from '../protocol/iq/router';
 import { type BinaryNode } from '../transport/codec';
 import { type SignalKeyPair } from '../transport/crypto';
 import type { WaFakeConnection } from './WaFakeConnection';
@@ -10,7 +9,12 @@ export interface WaFakeConnectionPipelineConfig {
     readonly connection: WaFakeConnection;
     readonly rootCa: FakeNoiseRootCa;
     readonly serverStaticKeyPair: SignalKeyPair;
-    readonly iqRouter: WaFakeIqRouter;
+    /**
+     * Routes an inbound IQ against the session this connection is bound to.
+     * The server resolves the session per connection, so the pipeline stays
+     * unaware of session identity.
+     */
+    readonly routeIq: (iq: BinaryNode) => Promise<BinaryNode | null>;
     readonly successNodeAttributes?: Parameters<typeof buildSuccessNode>[0];
 }
 export interface WaFakeConnectionPipelineEvents {
@@ -33,9 +37,12 @@ export declare class WaFakeConnectionPipeline {
     private events;
     private state;
     private chain;
+    private authenticatedPayload;
     constructor(config: WaFakeConnectionPipelineConfig);
     setEvents(events: WaFakeConnectionPipelineEvents): void;
     isAuthenticated(): boolean;
+    /** Parsed ClientPayload of the authenticated connection; null before auth. */
+    get clientPayload(): ParsedClientPayload | null;
     sendStanza(node: BinaryNode): Promise<void>;
     private onPrologue;
     private scheduleFrame;
@@ -45,7 +52,7 @@ export declare class WaFakeConnectionPipeline {
     /** Server-side IK path used when the client already cached our static key. */
     private handleIkClientHello;
     private handleClientFinish;
+    private completeAuthentication;
     private handleAuthenticatedFrame;
     private fail;
 }
-//# sourceMappingURL=WaFakeConnectionPipeline.d.ts.map

package/dist/infra/WaFakeConnectionPipeline.js

@@ -19,6 +19,7 @@ class WaFakeConnectionPipeline {
         this.events = {};
         this.state = { kind: 'awaiting_prologue' };
         this.chain = Promise.resolve();
+        this.authenticatedPayload = null;
         this.config = config;
         this.frameSocket = new WaFakeFrameSocket_1.WaFakeFrameSocket(config.connection);
         this.frameSocket.setHandlers({
@@ -37,6 +38,10 @@ class WaFakeConnectionPipeline {
     isAuthenticated() {
         return this.state.kind === 'authenticated';
     }
+    /** Parsed ClientPayload of the authenticated connection; null before auth. */
+    get clientPayload() {
+        return this.authenticatedPayload;
+    }
     async sendStanza(node) {
         if (this.state.kind !== 'authenticated') {
             throw new Error(`cannot send stanza while pipeline is in state "${this.state.kind}"`);
@@ -92,18 +97,18 @@ class WaFakeConnectionPipeline {
     }
     async handleXxClientHello(clientEphemeralPub) {
         const handshake = new WaFakeNoiseHandshake_1.WaFakeNoiseHandshake();
-        await handshake.start(NOISE_XX_NAME, PROLOGUE);
-        await handshake.authenticate(clientEphemeralPub);
+        handshake.start(NOISE_XX_NAME, PROLOGUE);
+        handshake.authenticate(clientEphemeralPub);
         const serverEphemeral = await crypto_1.X25519.generateKeyPair();
-        await handshake.authenticate(serverEphemeral.pubKey);
-        await handshake.mixIntoKey(await crypto_1.X25519.scalarMult(serverEphemeral.privKey, clientEphemeralPub));
-        const encryptedServerStatic = await handshake.encrypt(this.config.serverStaticKeyPair.pubKey);
-        await handshake.mixIntoKey(await crypto_1.X25519.scalarMult(this.config.serverStaticKeyPair.privKey, clientEphemeralPub));
+        handshake.authenticate(serverEphemeral.pubKey);
+        handshake.mixIntoKey(await crypto_1.X25519.scalarMult(serverEphemeral.privKey, clientEphemeralPub));
+        const encryptedServerStatic = handshake.encrypt(this.config.serverStaticKeyPair.pubKey);
+        handshake.mixIntoKey(await crypto_1.X25519.scalarMult(this.config.serverStaticKeyPair.privKey, clientEphemeralPub));
         const certChain = await (0, cert_chain_1.buildFakeCertChain)({
             root: this.config.rootCa,
             leafKey: this.config.serverStaticKeyPair.pubKey
         });
-        const encryptedCertPayload = await handshake.encrypt(certChain.encoded);
+        const encryptedCertPayload = handshake.encrypt(certChain.encoded);
         const serverHello = protos_1.proto.HandshakeMessage.encode({
             serverHello: {
                 ephemeral: serverEphemeral.pubKey,
@@ -128,23 +133,27 @@ class WaFakeConnectionPipeline {
         const encryptedClientStatic = clientHello.static;
         const encryptedClientPayload = clientHello.payload;
         const handshake = new WaFakeNoiseHandshake_1.WaFakeNoiseHandshake();
-        await handshake.start(NOISE_IK_NAME, PROLOGUE);
-        await handshake.authenticate(this.config.serverStaticKeyPair.pubKey);
-        await handshake.authenticate(clientEphemeralPub);
-        await handshake.mixIntoKey(await crypto_1.X25519.scalarMult(this.config.serverStaticKeyPair.privKey, clientEphemeralPub));
-        const clientStaticKey = await handshake.decrypt(encryptedClientStatic);
-        await handshake.mixIntoKey(await crypto_1.X25519.scalarMult(this.config.serverStaticKeyPair.privKey, clientStaticKey));
-        const clientPayloadBytes = await handshake.decrypt(encryptedClientPayload);
+        handshake.start(NOISE_IK_NAME, PROLOGUE);
+        handshake.authenticate(this.config.serverStaticKeyPair.pubKey);
+        handshake.authenticate(clientEphemeralPub);
+        handshake.mixIntoKey(await crypto_1.X25519.scalarMult(this.config.serverStaticKeyPair.privKey, clientEphemeralPub));
+        const clientStaticKey = handshake.decrypt(encryptedClientStatic);
+        handshake.mixIntoKey(await crypto_1.X25519.scalarMult(this.config.serverStaticKeyPair.privKey, clientStaticKey));
+        const clientPayloadBytes = handshake.decrypt(encryptedClientPayload);
         const clientPayload = (0, client_payload_validate_1.parseClientPayload)(clientPayloadBytes);
         const serverEphemeral = await crypto_1.X25519.generateKeyPair();
-        await handshake.authenticate(serverEphemeral.pubKey);
-        await handshake.mixIntoKey(await crypto_1.X25519.scalarMult(serverEphemeral.privKey, clientEphemeralPub));
-        await handshake.mixIntoKey(await crypto_1.X25519.scalarMult(serverEphemeral.privKey, clientStaticKey));
+        handshake.authenticate(serverEphemeral.pubKey);
+        const [dhEphem, dhStatic] = await Promise.all([
+            crypto_1.X25519.scalarMult(serverEphemeral.privKey, clientEphemeralPub),
+            crypto_1.X25519.scalarMult(serverEphemeral.privKey, clientStaticKey)
+        ]);
+        handshake.mixIntoKey(dhEphem);
+        handshake.mixIntoKey(dhStatic);
         const certChain = await (0, cert_chain_1.buildFakeCertChain)({
             root: this.config.rootCa,
             leafKey: this.config.serverStaticKeyPair.pubKey
         });
-        const encryptedCertPayload = await handshake.encrypt(certChain.encoded);
+        const encryptedCertPayload = handshake.encrypt(certChain.encoded);
         const serverHello = protos_1.proto.HandshakeMessage.encode({
             serverHello: {
                 ephemeral: serverEphemeral.pubKey,
@@ -152,14 +161,7 @@ class WaFakeConnectionPipeline {
             }
         }).finish();
         this.frameSocket.sendFrame(serverHello);
-        const keys = await handshake.finish();
-        const transport = new WaFakeTransport_1.WaFakeTransport({
-            recvKey: keys.recvKey,
-            sendKey: keys.sendKey
-        });
-        this.state = { kind: 'authenticated', transport };
-        await this.sendStanza((0, success_node_1.buildSuccessNode)(this.config.successNodeAttributes));
-        this.events.onAuthenticated?.({ clientPayload, clientStaticKey });
+        await this.completeAuthentication(handshake, clientPayload, clientStaticKey);
     }
     async handleClientFinish(frame, handshake, serverEphemeralKeyPair) {
         const parsed = protos_1.proto.HandshakeMessage.decode(frame);
@@ -167,17 +169,31 @@ class WaFakeConnectionPipeline {
         if (!clientFinish?.static || !clientFinish.payload) {
             throw new Error('ClientFinish missing static/payload');
         }
-        const clientStaticKey = await handshake.decrypt(clientFinish.static);
-        await handshake.mixIntoKey(await crypto_1.X25519.scalarMult(serverEphemeralKeyPair.privKey, clientStaticKey));
-        const clientPayloadBytes = await handshake.decrypt(clientFinish.payload);
+        const clientStaticKey = handshake.decrypt(clientFinish.static);
+        handshake.mixIntoKey(await crypto_1.X25519.scalarMult(serverEphemeralKeyPair.privKey, clientStaticKey));
+        const clientPayloadBytes = handshake.decrypt(clientFinish.payload);
         const clientPayload = (0, client_payload_validate_1.parseClientPayload)(clientPayloadBytes);
-        const keys = await handshake.finish();
+        await this.completeAuthentication(handshake, clientPayload, clientStaticKey);
+    }
+    async completeAuthentication(handshake, clientPayload, clientStaticKey) {
+        const keys = handshake.finish();
         const transport = new WaFakeTransport_1.WaFakeTransport({
             recvKey: keys.recvKey,
             sendKey: keys.sendKey
         });
         this.state = { kind: 'authenticated', transport };
+        this.authenticatedPayload = clientPayload;
         await this.sendStanza((0, success_node_1.buildSuccessNode)(this.config.successNodeAttributes));
+        if (clientPayload.kind === 'login') {
+            // Real WA drains offline messages after login and closes the
+            // drain with this bulletin. Baileys-family clients buffer their
+            // events until it arrives, so send it eagerly with count=0.
+            await this.sendStanza({
+                tag: 'ib',
+                attrs: { from: 's.whatsapp.net' },
+                content: [{ tag: 'offline', attrs: { count: '0' } }]
+            });
+        }
         this.events.onAuthenticated?.({ clientPayload, clientStaticKey });
     }
     async handleAuthenticatedFrame(frame, transport) {
@@ -185,7 +201,7 @@ class WaFakeConnectionPipeline {
         const node = await (0, codec_1.decodeBinaryNodeStanza)(stanzaBytes);
         this.events.onStanza?.(node);
         if (node.tag === 'iq') {
-            const response = await this.config.iqRouter.route(node);
+            const response = await this.config.routeIq(node);
             if (response !== null) {
                 await this.sendStanza(response);
             }
@@ -221,4 +237,3 @@ class WaFakeConnectionPipeline {
     }
 }
 exports.WaFakeConnectionPipeline = WaFakeConnectionPipeline;
-//# sourceMappingURL=WaFakeConnectionPipeline.js.map

package/dist/infra/WaFakeFrameSocket.d.ts

@@ -26,4 +26,3 @@ export declare class WaFakeFrameSocket {
     private tryParsePrologue;
     private drainFrames;
 }
-//# sourceMappingURL=WaFakeFrameSocket.d.ts.map

package/dist/infra/WaFakeFrameSocket.js

@@ -119,4 +119,3 @@ function hex(byte) {
         return 'undefined';
     return `0x${byte.toString(16).padStart(2, '0')}`;
 }
-//# sourceMappingURL=WaFakeFrameSocket.js.map

package/dist/infra/WaFakeMediaHttpsServer.d.ts

@@ -13,4 +13,3 @@ export declare class WaFakeMediaHttpsServer {
     close(): Promise<void>;
     get info(): WaFakeMediaHttpsServerListenInfo | null;
 }
-//# sourceMappingURL=WaFakeMediaHttpsServer.d.ts.map

package/dist/infra/WaFakeMediaHttpsServer.js

@@ -128,4 +128,3 @@ class WaFakeMediaHttpsServer {
     }
 }
 exports.WaFakeMediaHttpsServer = WaFakeMediaHttpsServer;
-//# sourceMappingURL=WaFakeMediaHttpsServer.js.map

package/dist/infra/WaFakeNoiseHandshake.d.ts

@@ -1,8 +1,7 @@
 /** Responder-side Noise handshake primitives for fake server pipelines. */
-import { type CryptoKey } from '../transport/crypto';
 export interface WaFakeNoiseHandshakeFinishKeys {
-    readonly recvKey: CryptoKey;
-    readonly sendKey: CryptoKey;
+    readonly recvKey: Uint8Array;
+    readonly sendKey: Uint8Array;
     readonly recvKeyBytes: Uint8Array;
     readonly sendKeyBytes: Uint8Array;
 }
@@ -11,13 +10,12 @@ export declare class WaFakeNoiseHandshake {
     private chainingKey;
     private cipherKey;
     private nonceCounter;
-    start(name: Uint8Array, prologue: Uint8Array): Promise<void>;
-    authenticate(data: Uint8Array): Promise<void>;
-    mixIntoKey(input: Uint8Array): Promise<void>;
-    encrypt(plaintext: Uint8Array): Promise<Uint8Array>;
-    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+    start(name: Uint8Array, prologue: Uint8Array): void;
+    authenticate(data: Uint8Array): void;
+    mixIntoKey(input: Uint8Array): void;
+    encrypt(plaintext: Uint8Array): Uint8Array;
+    decrypt(ciphertext: Uint8Array): Uint8Array;
     /** Derives transport keys (`first -> recv`, `second -> send` for responder role). */
-    finish(): Promise<WaFakeNoiseHandshakeFinishKeys>;
+    finish(): WaFakeNoiseHandshakeFinishKeys;
     private buildNonceIv;
 }
-//# sourceMappingURL=WaFakeNoiseHandshake.d.ts.map

package/dist/infra/WaFakeNoiseHandshake.js

@@ -11,56 +11,52 @@ class WaFakeNoiseHandshake {
         this.cipherKey = null;
         this.nonceCounter = 0;
     }
-    async start(name, prologue) {
-        const initialHash = name.byteLength === 32 ? name : await (0, crypto_1.sha256)(name);
+    start(name, prologue) {
+        const initialHash = name.byteLength === 32 ? name : (0, crypto_1.sha256)(name);
         this.hash = initialHash;
         this.chainingKey = initialHash;
-        this.cipherKey = await (0, crypto_1.importAesGcmKey)(initialHash, ['encrypt', 'decrypt']);
+        this.cipherKey = initialHash;
         this.nonceCounter = 0;
-        await this.authenticate(prologue);
+        this.authenticate(prologue);
     }
-    async authenticate(data) {
+    authenticate(data) {
         const concatenated = new Uint8Array(this.hash.byteLength + data.byteLength);
         concatenated.set(this.hash, 0);
         concatenated.set(data, this.hash.byteLength);
-        this.hash = await (0, crypto_1.sha256)(concatenated);
+        this.hash = (0, crypto_1.sha256)(concatenated);
     }
-    async mixIntoKey(input) {
-        const [nextChainingKey, nextCipherMaterial] = await (0, crypto_1.hkdfSplit)(input, this.chainingKey, '');
+    mixIntoKey(input) {
+        const [nextChainingKey, nextCipherMaterial] = (0, crypto_1.hkdfSplit)(input, this.chainingKey, EMPTY);
         this.chainingKey = nextChainingKey;
-        this.cipherKey = await (0, crypto_1.importAesGcmKey)(nextCipherMaterial, ['encrypt', 'decrypt']);
+        this.cipherKey = nextCipherMaterial;
         this.nonceCounter = 0;
     }
-    async encrypt(plaintext) {
+    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 = await (0, crypto_1.aesGcmEncrypt)(this.cipherKey, iv, plaintext, this.hash);
-        await this.authenticate(ciphertext);
+        const ciphertext = (0, crypto_1.aesGcmEncrypt)(this.cipherKey, iv, plaintext, this.hash);
+        this.authenticate(ciphertext);
         return ciphertext;
     }
-    async decrypt(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 = await (0, crypto_1.aesGcmDecrypt)(this.cipherKey, iv, ciphertext, this.hash);
-        await this.authenticate(ciphertext);
+        const plaintext = (0, crypto_1.aesGcmDecrypt)(this.cipherKey, iv, ciphertext, this.hash);
+        this.authenticate(ciphertext);
         return plaintext;
     }
     /** Derives transport keys (`first -> recv`, `second -> send` for responder role). */
-    async finish() {
-        const [first, second] = await (0, crypto_1.hkdfSplit)(EMPTY, this.chainingKey, '');
-        const [recvKey, sendKey] = await Promise.all([
-            (0, crypto_1.importAesGcmKey)(first, ['decrypt']),
-            (0, crypto_1.importAesGcmKey)(second, ['encrypt'])
-        ]);
+    finish() {
+        const [first, second] = (0, crypto_1.hkdfSplit)(EMPTY, this.chainingKey, EMPTY);
         return {
-            recvKey,
-            sendKey,
+            recvKey: first,
+            sendKey: second,
             recvKeyBytes: first,
             sendKeyBytes: second
         };
@@ -73,4 +69,3 @@ class WaFakeNoiseHandshake {
     }
 }
 exports.WaFakeNoiseHandshake = WaFakeNoiseHandshake;
-//# sourceMappingURL=WaFakeNoiseHandshake.js.map

package/dist/infra/WaFakeTransport.d.ts

@@ -1,15 +1,13 @@
 /** Post-handshake Noise transport (AES-GCM with direction-specific counters). */
-import { type CryptoKey } from '../transport/crypto';
 export declare class WaFakeTransport {
     private readonly recvKey;
     private readonly sendKey;
     private sendCounter;
     private recvCounter;
     constructor(keys: {
-        readonly recvKey: CryptoKey;
-        readonly sendKey: CryptoKey;
+        readonly recvKey: Uint8Array;
+        readonly sendKey: Uint8Array;
     });
     encryptFrame(plaintext: Uint8Array): Promise<Uint8Array>;
     decryptFrame(ciphertext: Uint8Array): Promise<Uint8Array>;
 }
-//# sourceMappingURL=WaFakeTransport.d.ts.map

package/dist/infra/WaFakeTransport.js

@@ -10,11 +10,13 @@ class WaFakeTransport {
         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 (0, crypto_1.aesGcmEncrypt)(this.sendKey, nonce, plaintext);
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async decryptFrame(ciphertext) {
         const nonce = buildAesGcmNonce(this.recvCounter);
         this.recvCounter += 1;
@@ -31,4 +33,3 @@ function buildAesGcmNonce(counter) {
     view.setUint32(8, counter, false);
     return nonce;
 }
-//# sourceMappingURL=WaFakeTransport.js.map

package/dist/infra/WaFakeWsServer.d.ts

@@ -26,4 +26,3 @@ export declare class WaFakeWsServer {
     listen(): Promise<WaFakeWsServerListenInfo>;
     close(): Promise<void>;
 }
-//# sourceMappingURL=WaFakeWsServer.d.ts.map

package/dist/infra/WaFakeWsServer.js

@@ -98,4 +98,3 @@ class WaFakeWsServer {
     }
 }
 exports.WaFakeWsServer = WaFakeWsServer;
-//# sourceMappingURL=WaFakeWsServer.js.map

package/dist/protocol/auth/cert-chain.d.ts

@@ -12,7 +12,10 @@ export interface BuildFakeCertChainInput {
     readonly leafKey: Uint8Array;
     readonly intermediateSerial?: number;
     readonly leafSerial?: number;
+    /** Unix seconds. Defaults to 24h before build time. */
+    readonly notBefore?: number;
+    /** Unix seconds. Defaults to 10 years after build time. */
+    readonly notAfter?: number;
 }
 export declare function generateFakeNoiseRootCa(): Promise<FakeNoiseRootCa>;
 export declare function buildFakeCertChain(input: BuildFakeCertChainInput): Promise<FakeCertChainResult>;
-//# sourceMappingURL=cert-chain.d.ts.map

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

@@ -5,6 +5,8 @@ exports.generateFakeNoiseRootCa = generateFakeNoiseRootCa;
 exports.buildFakeCertChain = buildFakeCertChain;
 const crypto_1 = require("../../transport/crypto");
 const protos_1 = require("../../transport/protos");
+const WA_CERT_NOT_BEFORE_BACKDATE_SECONDS = 86400;
+const WA_CERT_NOT_AFTER_LIFETIME_SECONDS = 315360000;
 async function generateFakeNoiseRootCa() {
     const keyPair = await crypto_1.X25519.generateKeyPair();
     return {
@@ -16,17 +18,26 @@ async function generateFakeNoiseRootCa() {
 async function buildFakeCertChain(input) {
     const intermediateSerial = input.intermediateSerial ?? 1;
     const leafSerial = input.leafSerial ?? 2;
+    // Strict clients (e.g. whatsmeow) enforce the validity window; leaving
+    // notBefore/notAfter unset decodes as 0 (1970) and reads as expired.
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const notBefore = input.notBefore ?? nowSeconds - WA_CERT_NOT_BEFORE_BACKDATE_SECONDS;
+    const notAfter = input.notAfter ?? nowSeconds + WA_CERT_NOT_AFTER_LIFETIME_SECONDS;
     const intermediateKeyPair = await crypto_1.X25519.generateKeyPair();
     const intermediateDetails = protos_1.proto.CertChain.NoiseCertificate.Details.encode({
         serial: intermediateSerial,
         issuerSerial: input.root.serial,
-        key: intermediateKeyPair.pubKey
+        key: intermediateKeyPair.pubKey,
+        notBefore,
+        notAfter
     }).finish();
     const intermediateSignature = await (0, crypto_1.xeddsaSign)(input.root.privateKey, intermediateDetails);
     const leafDetails = protos_1.proto.CertChain.NoiseCertificate.Details.encode({
         serial: leafSerial,
         issuerSerial: intermediateSerial,
-        key: input.leafKey
+        key: input.leafKey,
+        notBefore,
+        notAfter
     }).finish();
     const leafSignature = await (0, crypto_1.xeddsaSign)(intermediateKeyPair.privKey, leafDetails);
     const encoded = protos_1.proto.CertChain.encode({
@@ -41,4 +52,3 @@ async function buildFakeCertChain(input) {
     }).finish();
     return { encoded };
 }
-//# sourceMappingURL=cert-chain.js.map

package/dist/protocol/auth/client-payload-validate.d.ts

@@ -18,4 +18,3 @@ export declare class ClientPayloadValidationError extends Error {
     constructor(code: string, message: string);
 }
 export declare function parseClientPayload(bytes: Uint8Array): ParsedClientPayload;
-//# sourceMappingURL=client-payload-validate.d.ts.map

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

@@ -58,4 +58,3 @@ function validateRegistrationFields(devicePairingData) {
         }
     }
 }
-//# sourceMappingURL=client-payload-validate.js.map

package/dist/protocol/auth/fake-primary-device.d.ts

@@ -16,4 +16,3 @@ export interface BuildAdvIdentityResult {
     readonly deviceIdentityBytes: Uint8Array;
 }
 export declare function buildAdvSignedDeviceIdentity(input: BuildAdvIdentityInput): Promise<BuildAdvIdentityResult>;
-//# sourceMappingURL=fake-primary-device.d.ts.map

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

@@ -30,8 +30,7 @@ async function buildAdvSignedDeviceIdentity(input) {
         accountSignatureKey,
         accountSignature
     }).finish();
-    const hmacKey = await (0, crypto_1.importHmacKey)(input.advSecretKey);
-    const hmac = await (0, crypto_1.hmacSign)(hmacKey, signedIdentity);
+    const hmac = (0, crypto_1.hmacSha256Sign)(input.advSecretKey, signedIdentity);
     const wrapped = protos_1.proto.ADVSignedDeviceIdentityHMAC.encode({
         details: signedIdentity,
         hmac
@@ -50,4 +49,3 @@ function concatBytes(parts) {
     }
     return out;
 }
-//# sourceMappingURL=fake-primary-device.js.map

package/dist/protocol/auth/pair-device.d.ts

@@ -23,4 +23,3 @@ export interface ParsedPairingQr {
     readonly platform: string;
 }
 export declare function parsePairingQrString(qr: string): ParsedPairingQr;
-//# sourceMappingURL=pair-device.d.ts.map

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPairDeviceIq = buildPairDeviceIq;
 exports.buildPairSuccessIq = buildPairSuccessIq;
 exports.parsePairingQrString = parsePairingQrString;
+const util_1 = require("../../transport/util");
 function buildPairDeviceIq(input) {
     if (input.refs.length !== 6) {
         throw new Error(`pair-device requires exactly 6 refs, got ${input.refs.length}`);
@@ -83,22 +84,9 @@ function parsePairingQrString(qr) {
     const ref = parts.slice(0, parts.length - 4).join(',');
     return {
         ref,
-        noisePublicKey: base64Decode(noisePubB64),
-        identityPublicKey: base64Decode(identityPubB64),
-        advSecretKey: base64Decode(advSecretB64),
+        noisePublicKey: (0, util_1.decodeBase64Url)(noisePubB64, 'qr.noisePublicKey'),
+        identityPublicKey: (0, util_1.decodeBase64Url)(identityPubB64, 'qr.identityPublicKey'),
+        advSecretKey: (0, util_1.decodeBase64Url)(advSecretB64, 'qr.advSecretKey'),
         platform
     };
 }
-function base64Decode(input) {
-    let normalized = input.replace(/-/g, '+').replace(/_/g, '/');
-    const remainder = normalized.length % 4;
-    if (remainder === 2)
-        normalized += '==';
-    else if (remainder === 3)
-        normalized += '=';
-    else if (remainder === 1) {
-        throw new Error(`invalid base64 string length: ${input.length}`);
-    }
-    return new Uint8Array(Buffer.from(normalized, 'base64'));
-}
-//# sourceMappingURL=pair-device.js.map

package/dist/protocol/auth/success-node.d.ts

@@ -12,4 +12,3 @@ export interface BuildSuccessNodeInput {
     readonly creation?: number;
 }
 export declare function buildSuccessNode(input?: BuildSuccessNodeInput): BinaryNode;
-//# sourceMappingURL=success-node.d.ts.map

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

@@ -27,4 +27,3 @@ function buildSuccessNode(input = {}) {
         attrs
     };
 }
-//# sourceMappingURL=success-node.js.map

package/dist/protocol/iq/abprops.d.ts

@@ -11,4 +11,3 @@ export interface BuildAbPropsResultInput {
     readonly props?: readonly FakeAbPropEntry[];
 }
 export declare function buildAbPropsResult(iq: BinaryNode, input?: BuildAbPropsResultInput): BinaryNode;
-//# sourceMappingURL=abprops.d.ts.map

package/dist/protocol/iq/abprops.js

@@ -31,4 +31,3 @@ function buildAbPropsResult(iq, input = {}) {
         ]
     };
 }
-//# sourceMappingURL=abprops.js.map

package/dist/protocol/iq/appstate-sync.d.ts

@@ -35,4 +35,3 @@ export interface BuildServerSyncNotificationInput {
 }
 export declare function buildServerSyncNotification(input: BuildServerSyncNotificationInput): BinaryNode;
 export {};
-//# sourceMappingURL=appstate-sync.d.ts.map

package/dist/protocol/iq/appstate-sync.js

@@ -151,4 +151,3 @@ function buildServerSyncNotification(input) {
         }))
     };
 }
-//# sourceMappingURL=appstate-sync.js.map

package/dist/protocol/iq/business.d.ts

@@ -10,4 +10,3 @@ export interface FakeBusinessProfile {
 }
 export declare function buildBusinessProfileResult(iq: BinaryNode, profiles: readonly FakeBusinessProfile[]): BinaryNode;
 export declare function parseGetBusinessProfileIq(iq: BinaryNode): readonly string[] | null;
-//# sourceMappingURL=business.d.ts.map

package/dist/protocol/iq/business.js

@@ -61,4 +61,3 @@ function parseGetBusinessProfileIq(iq) {
     }
     return jids;
 }
-//# sourceMappingURL=business.js.map

package/dist/protocol/iq/dirty-bits.d.ts

@@ -5,4 +5,3 @@ export interface FakeClearedDirtyBit {
     readonly timestamp: number;
 }
 export declare function parseClearDirtyBitsIq(iq: BinaryNode): readonly FakeClearedDirtyBit[] | null;
-//# sourceMappingURL=dirty-bits.d.ts.map

package/dist/protocol/iq/dirty-bits.js

@@ -20,4 +20,3 @@ function parseClearDirtyBitsIq(iq) {
     }
     return out.length > 0 ? out : null;
 }
-//# sourceMappingURL=dirty-bits.js.map

package/dist/protocol/iq/group-ops.d.ts

@@ -31,4 +31,3 @@ export declare function buildGroupMetadataNode(input: {
     readonly description?: string;
     readonly descriptionId?: string;
 }): BinaryNode;
-//# sourceMappingURL=group-ops.d.ts.map

package/dist/protocol/iq/group-ops.js

@@ -161,4 +161,3 @@ function decodeNodeContentToString(content) {
         return new TextDecoder().decode(content);
     return undefined;
 }
-//# sourceMappingURL=group-ops.js.map

package/dist/protocol/iq/newsletter.d.ts

@@ -1,4 +1,3 @@
 /** Builds the `newsletter/my_addons` IQ result expected by the lib. */
 import type { BinaryNode } from '../../transport/codec';
 export declare function buildNewsletterMyAddonsResult(iq: BinaryNode): BinaryNode;
-//# sourceMappingURL=newsletter.d.ts.map

package/dist/protocol/iq/newsletter.js

@@ -15,4 +15,3 @@ function buildNewsletterMyAddonsResult(iq) {
         ]
     };
 }
-//# sourceMappingURL=newsletter.js.map

package/dist/protocol/iq/prekey-fetch.d.ts

@@ -15,4 +15,3 @@ export interface PreKeyBundleForUser {
     };
 }
 export declare function buildPreKeyFetchResult(inboundIq: BinaryNode, bundles: readonly PreKeyBundleForUser[]): BinaryNode;
-//# sourceMappingURL=prekey-fetch.d.ts.map

package/dist/protocol/iq/prekey-fetch.js

@@ -89,4 +89,3 @@ function bigEndianBytes(value, length) {
     }
     return out;
 }
-//# sourceMappingURL=prekey-fetch.js.map

package/dist/protocol/iq/privacy-token.d.ts

@@ -6,4 +6,3 @@ export interface FakePrivacyTokenIssue {
     readonly type: string;
 }
 export declare function parsePrivacyTokenIssueIq(iq: BinaryNode): readonly FakePrivacyTokenIssue[] | null;
-//# sourceMappingURL=privacy-token.d.ts.map

package/dist/protocol/iq/privacy-token.js

@@ -27,4 +27,3 @@ function parsePrivacyTokenIssueIq(iq) {
     }
     return out;
 }
-//# sourceMappingURL=privacy-token.js.map