zapo-js 0.1.0

package/dist/transport/node/helpers.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeChildren = getNodeChildren;
+exports.findNodeChild = findNodeChild;
+exports.getFirstNodeChild = getFirstNodeChild;
+exports.getNodeChildrenByTag = getNodeChildrenByTag;
+exports.hasNodeChild = hasNodeChild;
+exports.decodeNodeContentUtf8OrBytes = decodeNodeContentUtf8OrBytes;
+exports.decodeNodeContentBase64OrBytes = decodeNodeContentBase64OrBytes;
+const bytes_1 = require("../../util/bytes");
+function getNodeChildren(node) {
+    return Array.isArray(node.content) ? node.content : [];
+}
+function findNodeChild(node, tag) {
+    return getNodeChildren(node).find((child) => child.tag === tag);
+}
+function getFirstNodeChild(node) {
+    return getNodeChildren(node)[0];
+}
+function getNodeChildrenByTag(node, tag) {
+    return getNodeChildren(node).filter((child) => child.tag === tag);
+}
+function hasNodeChild(node, tag) {
+    return findNodeChild(node, tag) !== undefined;
+}
+function decodeNodeContentUtf8OrBytes(value, field) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return bytes_1.TEXT_ENCODER.encode(value);
+    }
+    throw new Error(`node ${field} has no binary content`);
+}
+function decodeNodeContentBase64OrBytes(value, field) {
+    if (value === null || value === undefined) {
+        throw new Error(`missing binary node content for ${field}`);
+    }
+    if (typeof value === 'string') {
+        return (0, bytes_1.base64ToBytes)(value);
+    }
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    throw new Error(`missing binary node content for ${field}`);
+}

package/dist/transport/node/query.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIqNode = buildIqNode;
+exports.parseIqError = parseIqError;
+exports.assertIqResult = assertIqResult;
+exports.queryWithContext = queryWithContext;
+const constants_1 = require("../../protocol/constants");
+const helpers_1 = require("../node/helpers");
+const primitives_1 = require("../../util/primitives");
+function buildIqNode(type, to, xmlns, content, attrs = {}) {
+    return {
+        tag: constants_1.WA_NODE_TAGS.IQ,
+        attrs: {
+            ...attrs,
+            to,
+            type,
+            xmlns
+        },
+        ...(content !== undefined ? { content } : {})
+    };
+}
+function parseIqError(node) {
+    const errorNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.ERROR);
+    const code = errorNode?.attrs.code ?? node.attrs.type ?? 'unknown';
+    const text = errorNode?.attrs.text ?? errorNode?.attrs.type ?? 'unknown';
+    const parsedCode = Number.parseInt(code, 10);
+    return {
+        code,
+        text,
+        ...(Number.isSafeInteger(parsedCode) ? { numericCode: parsedCode } : {})
+    };
+}
+function assertIqResult(node, context) {
+    if (node.tag !== constants_1.WA_NODE_TAGS.IQ) {
+        throw new Error(`${context} returned non-iq node (${node.tag})`);
+    }
+    if (node.attrs.type === constants_1.WA_IQ_TYPES.RESULT) {
+        return;
+    }
+    const error = parseIqError(node);
+    throw new Error(`${context} iq failed (${error.code}: ${error.text})`);
+}
+async function queryWithContext(query, logger, context, node, timeoutMs, contextData = {}) {
+    try {
+        return await query(node, timeoutMs);
+    }
+    catch (error) {
+        const normalized = (0, primitives_1.toError)(error);
+        logger.warn('query failed', {
+            context,
+            message: normalized.message,
+            tag: node.tag,
+            id: node.attrs.id,
+            type: node.attrs.type,
+            ...contextData
+        });
+        throw normalized;
+    }
+}

package/dist/transport/node/xml.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBinaryNodeAsXml = formatBinaryNodeAsXml;
+const bytes_1 = require("../../util/bytes");
+const XML_INDENT = '    ';
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function renderAttrs(attrs) {
+    const entries = Object.entries(attrs);
+    if (entries.length === 0) {
+        return '';
+    }
+    return entries.map(([key, value]) => ` ${key}='${escapeXml(value)}'`).join('');
+}
+function renderNode(node, depth) {
+    const indent = XML_INDENT.repeat(depth);
+    const attrs = renderAttrs(node.attrs);
+    const content = node.content;
+    if (content === undefined) {
+        return `${indent}<${node.tag}${attrs}/>`;
+    }
+    if (typeof content === 'string') {
+        return `${indent}<${node.tag}${attrs}>${escapeXml(content)}</${node.tag}>`;
+    }
+    if (content instanceof Uint8Array) {
+        return `${indent}<${node.tag}${attrs}>${(0, bytes_1.bytesToBase64)(content)}</${node.tag}>`;
+    }
+    if (content.length === 0) {
+        return `${indent}<${node.tag}${attrs}/>`;
+    }
+    const children = content.map((child) => renderNode(child, depth + 1)).join('\n');
+    return `${indent}<${node.tag}${attrs}>\n${children}\n${indent}</${node.tag}>`;
+}
+function formatBinaryNodeAsXml(node) {
+    return renderNode(node, 0);
+}

package/dist/transport/noise/WaClientPayload.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLoginPayload = buildLoginPayload;
+exports.buildRegistrationPayload = buildRegistrationPayload;
+const node_crypto_1 = require("node:crypto");
+const primitives_1 = require("../../crypto/core/primitives");
+const _proto_1 = require("../../proto.js");
+const constants_1 = require("../../signal/constants");
+const constants_2 = require("../noise/constants");
+const bytes_1 = require("../../util/bytes");
+function parseVersion(versionBase) {
+    const [p = '2', s = '3000', t = '0'] = versionBase.split('.');
+    const primary = Number.parseInt(p, 10);
+    const secondary = Number.parseInt(s, 10);
+    const tertiary = Number.parseInt(t, 10);
+    if (!Number.isSafeInteger(primary) ||
+        !Number.isSafeInteger(secondary) ||
+        !Number.isSafeInteger(tertiary)) {
+        throw new Error(`invalid versionBase: ${versionBase}`);
+    }
+    return { primary, secondary, tertiary };
+}
+function resolveLocale() {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en-US';
+    const [language = 'en', country = 'US'] = locale.split('-');
+    return {
+        lg: language.toLowerCase(),
+        lc: country.toUpperCase()
+    };
+}
+function defaultWebSubPlatform() {
+    return _proto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+}
+function resolveDevicePropsPlatformType(deviceBrowser) {
+    const normalized = deviceBrowser?.trim().toLowerCase();
+    switch (normalized) {
+        case 'chrome':
+            return _proto_1.proto.DeviceProps.PlatformType.CHROME;
+        case 'firefox':
+            return _proto_1.proto.DeviceProps.PlatformType.FIREFOX;
+        case 'ie':
+            return _proto_1.proto.DeviceProps.PlatformType.IE;
+        case 'opera':
+            return _proto_1.proto.DeviceProps.PlatformType.OPERA;
+        case 'safari':
+            return _proto_1.proto.DeviceProps.PlatformType.SAFARI;
+        case 'edge':
+            return _proto_1.proto.DeviceProps.PlatformType.EDGE;
+        case 'electron':
+        case 'desktop':
+            return _proto_1.proto.DeviceProps.PlatformType.DESKTOP;
+        case 'ipad':
+            return _proto_1.proto.DeviceProps.PlatformType.IPAD;
+        case 'tablet':
+        case 'android tablet':
+            return _proto_1.proto.DeviceProps.PlatformType.ANDROID_TABLET;
+        case 'ohana':
+            return _proto_1.proto.DeviceProps.PlatformType.OHANA;
+        case 'aloha':
+            return _proto_1.proto.DeviceProps.PlatformType.ALOHA;
+        case 'catalina':
+            return _proto_1.proto.DeviceProps.PlatformType.CATALINA;
+        default:
+            return _proto_1.proto.DeviceProps.PlatformType.UNKNOWN;
+    }
+}
+function defaultUserAgent(versionBase, deviceOsDisplayName) {
+    const { primary, secondary, tertiary } = parseVersion(versionBase);
+    const locale = resolveLocale();
+    return {
+        platform: _proto_1.proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: _proto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        appVersion: {
+            primary,
+            secondary,
+            tertiary
+        },
+        mcc: '000',
+        mnc: '000',
+        osVersion: deviceOsDisplayName ?? process.platform,
+        manufacturer: '',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        phoneId: (0, node_crypto_1.randomUUID)(),
+        localeLanguageIso6391: locale.lg,
+        localeCountryIso31661Alpha2: locale.lc
+    };
+}
+function defaultDeviceProps(versionBase, config) {
+    const { primary, secondary, tertiary } = parseVersion(versionBase);
+    return _proto_1.proto.DeviceProps.encode({
+        os: config.deviceOsDisplayName ?? process.platform,
+        version: {
+            primary,
+            secondary,
+            tertiary
+        },
+        platformType: resolveDevicePropsPlatformType(config.deviceBrowser),
+        requireFullSync: config.requireFullSync === true,
+        historySyncConfig: {
+            inlineInitialPayloadInE2EeMsg: true,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportBizHostedMsg: true,
+            supportFbidBotChatHistory: true,
+            supportMessageAssociation: true
+        }
+    }).finish();
+}
+function buildCommonPayload(config) {
+    const versionBase = config.versionBase ?? constants_2.DEFAULT_VERSION_BASE;
+    const pull = config.pull ?? true;
+    return {
+        passive: config.passive === true,
+        pull,
+        connectType: _proto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: _proto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: config.userAgent ?? defaultUserAgent(versionBase, config.deviceOsDisplayName),
+        webInfo: config.webInfo ??
+            {
+                webSubPlatform: defaultWebSubPlatform()
+            }
+    };
+}
+function buildLoginPayload(config) {
+    if (!Number.isSafeInteger(config.username) || config.username <= 0) {
+        throw new Error('login payload requires a valid numeric username');
+    }
+    const common = buildCommonPayload(config);
+    return _proto_1.proto.ClientPayload.encode({
+        ...common,
+        username: config.username,
+        device: config.device ?? 0,
+        lidDbMigrated: config.lidDbMigrated === true
+    }).finish();
+}
+function buildRegistrationPayload(config) {
+    const registrationId = config.registrationInfo.registrationId;
+    const signedPreKeyId = config.signedPreKey.keyId;
+    if (!Number.isSafeInteger(registrationId) || registrationId <= 0) {
+        throw new Error('registration payload requires a valid registrationId');
+    }
+    if (!Number.isSafeInteger(signedPreKeyId) || signedPreKeyId <= 0) {
+        throw new Error('registration payload requires a valid signedPreKeyId');
+    }
+    const versionBase = config.versionBase ?? constants_2.DEFAULT_VERSION_BASE;
+    const common = buildCommonPayload(config);
+    const devicePairingData = {
+        buildHash: config.buildHash ? (0, bytes_1.toBytesView)(config.buildHash) : (0, primitives_1.md5Bytes)(versionBase),
+        deviceProps: config.deviceProps
+            ? (0, bytes_1.toBytesView)(config.deviceProps)
+            : defaultDeviceProps(versionBase, config),
+        eRegid: (0, bytes_1.intToBytes)(4, registrationId),
+        eKeytype: (0, bytes_1.intToBytes)(1, constants_1.KEY_TYPE_CURVE25519),
+        eIdent: (0, bytes_1.toBytesView)(config.registrationInfo.identityKeyPair.pubKey),
+        eSkeyId: (0, bytes_1.intToBytes)(3, signedPreKeyId),
+        eSkeyVal: (0, bytes_1.toBytesView)(config.signedPreKey.keyPair.pubKey),
+        eSkeySig: (0, bytes_1.toBytesView)(config.signedPreKey.signature)
+    };
+    return _proto_1.proto.ClientPayload.encode({
+        ...common,
+        devicePairingData
+    }).finish();
+}

package/dist/transport/noise/WaFrameCodec.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaFrameCodec = void 0;
+const bytes_1 = require("../../util/bytes");
+const WA_MAX_FRAME_LENGTH = (1 << 24) - 1;
+function frameLength(header) {
+    return (header[0] << 16) | (header[1] << 8) | header[2];
+}
+class WaFrameCodec {
+    constructor(introFrame, maxFrameLength = WA_MAX_FRAME_LENGTH) {
+        if (!Number.isSafeInteger(maxFrameLength) || maxFrameLength <= 0) {
+            throw new Error('maxFrameLength must be a positive safe integer');
+        }
+        if (maxFrameLength >= 1 << 24) {
+            throw new Error('maxFrameLength must be lower than protocol limit (16777216)');
+        }
+        this.introFrame = introFrame && introFrame.length > 0 ? (0, bytes_1.toBytesView)(introFrame) : null;
+        this.maxFrameLength = maxFrameLength;
+        this.introSent = false;
+        this.buffered = bytes_1.EMPTY_BYTES;
+    }
+    encodeFrame(frame) {
+        if (frame.length > this.maxFrameLength) {
+            throw new Error(`frame is too large: ${frame.length} bytes (max allowed: ${this.maxFrameLength})`);
+        }
+        if (!this.introSent && this.introFrame) {
+            this.introSent = true;
+            const out = new Uint8Array(this.introFrame.length + 3 + frame.length);
+            out.set(this.introFrame, 0);
+            const headerOffset = this.introFrame.length;
+            out[headerOffset] = (frame.length >> 16) & 0xff;
+            out[headerOffset + 1] = (frame.length >> 8) & 0xff;
+            out[headerOffset + 2] = frame.length & 0xff;
+            out.set(frame, headerOffset + 3);
+            return out;
+        }
+        this.introSent = true;
+        const out = new Uint8Array(3 + frame.length);
+        out[0] = (frame.length >> 16) & 0xff;
+        out[1] = (frame.length >> 8) & 0xff;
+        out[2] = frame.length & 0xff;
+        out.set(frame, 3);
+        return out;
+    }
+    pushWireChunk(chunk) {
+        if (chunk.length === 0) {
+            return [];
+        }
+        const frames = [];
+        let chunkOffset = 0;
+        if (this.buffered.length > 0) {
+            if (this.buffered.length < 3) {
+                const missingHeaderBytes = 3 - this.buffered.length;
+                if (chunk.length < missingHeaderBytes) {
+                    this.buffered = (0, bytes_1.concatBytes)([this.buffered, chunk]);
+                    return frames;
+                }
+                const header = new Uint8Array(3);
+                header.set(this.buffered, 0);
+                header.set(chunk.subarray(0, missingHeaderBytes), this.buffered.length);
+                const length = frameLength(header);
+                if (length > this.maxFrameLength) {
+                    throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
+                }
+                const remainingAfterHeader = chunk.length - missingHeaderBytes;
+                if (remainingAfterHeader < length) {
+                    const nextBuffered = new Uint8Array(3 + remainingAfterHeader);
+                    nextBuffered.set(header, 0);
+                    nextBuffered.set(chunk.subarray(missingHeaderBytes), 3);
+                    this.buffered = nextBuffered;
+                    return frames;
+                }
+                frames.push(chunk.subarray(missingHeaderBytes, missingHeaderBytes + length));
+                chunkOffset = missingHeaderBytes + length;
+                this.buffered = bytes_1.EMPTY_BYTES;
+            }
+            else {
+                const header = this.buffered.subarray(0, 3);
+                const length = frameLength(header);
+                if (length > this.maxFrameLength) {
+                    throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
+                }
+                const bufferedPayloadLength = this.buffered.length - 3;
+                const missingPayloadBytes = length - bufferedPayloadLength;
+                if (missingPayloadBytes > chunk.length) {
+                    this.buffered = (0, bytes_1.concatBytes)([this.buffered, chunk]);
+                    return frames;
+                }
+                if (bufferedPayloadLength === 0) {
+                    frames.push(chunk.subarray(0, missingPayloadBytes));
+                }
+                else {
+                    const frame = new Uint8Array(length);
+                    frame.set(this.buffered.subarray(3), 0);
+                    if (missingPayloadBytes > 0) {
+                        frame.set(chunk.subarray(0, missingPayloadBytes), bufferedPayloadLength);
+                    }
+                    frames.push(frame);
+                }
+                chunkOffset = missingPayloadBytes;
+                this.buffered = bytes_1.EMPTY_BYTES;
+            }
+        }
+        const remainingChunk = chunk.subarray(chunkOffset);
+        let offset = 0;
+        while (remainingChunk.length - offset >= 3) {
+            const header = remainingChunk.subarray(offset, offset + 3);
+            const length = frameLength(header);
+            if (length > this.maxFrameLength) {
+                throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
+            }
+            if (remainingChunk.length - offset - 3 < length) {
+                break;
+            }
+            const start = offset + 3;
+            const end = start + length;
+            frames.push(remainingChunk.subarray(start, end));
+            offset = end;
+        }
+        this.buffered =
+            offset >= remainingChunk.length ? bytes_1.EMPTY_BYTES : remainingChunk.subarray(offset);
+        return frames;
+    }
+}
+exports.WaFrameCodec = WaFrameCodec;

package/dist/transport/noise/WaNoiseCert.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyNoiseCertificateChain = verifyNoiseCertificateChain;
+const _crypto_1 = require("../../crypto/index.js");
+const X25519_1 = require("../../crypto/curves/X25519");
+const _proto_1 = require("../../proto.js");
+const constants_1 = require("../noise/constants");
+const base64_1 = require("../../util/base64");
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
+async function verifySignalVariant(serializedPublicKey, message, signatureInput) {
+    const publicKey = (0, _crypto_1.toSerializedPubKey)(serializedPublicKey);
+    if (signatureInput.length !== 64) {
+        return false;
+    }
+    const signature = new Uint8Array(signatureInput);
+    const lastByte = signature[63];
+    if ((lastByte & 0x60) !== 0) {
+        return false;
+    }
+    const signBit = lastByte & 0x80;
+    signature[63] = lastByte & 0x7f;
+    const edwardsPublicKey = (0, X25519_1.montgomeryToEdwardsPublic)(publicKey.subarray(1), signBit);
+    return (0, _crypto_1.ed25519VerifyRaw)(edwardsPublicKey, signature, message);
+}
+function parseNoiseCertificate(certificate) {
+    if (!certificate) {
+        throw new Error('missing noise certificate');
+    }
+    const detailsBytes = (0, base64_1.decodeProtoBytes)(certificate.details, 'certificate.details');
+    const signatureBytes = (0, base64_1.decodeProtoBytes)(certificate.signature, 'certificate.signature');
+    if (signatureBytes.length !== 64) {
+        throw new Error('invalid certificate signature size');
+    }
+    const details = _proto_1.proto.CertChain.NoiseCertificate.Details.decode(detailsBytes);
+    const serial = (0, primitives_1.toSafeNumber)(details.serial, 'certificate.serial');
+    const issuerSerial = (0, primitives_1.toSafeNumber)(details.issuerSerial, 'certificate.issuerSerial');
+    const key = (0, base64_1.decodeProtoBytes)(details.key, 'certificate.key');
+    return {
+        serial,
+        issuerSerial,
+        key,
+        details: detailsBytes,
+        signature: signatureBytes
+    };
+}
+function rootPublicKeySerialized() {
+    const raw = (0, bytes_1.hexToBytes)(constants_1.ROOT_CA_PUBLIC_KEY_HEX);
+    return (0, _crypto_1.toSerializedPubKey)(raw);
+}
+async function verifyNoiseCertificateChain(certificateChain, serverStatic) {
+    const chain = _proto_1.proto.CertChain.decode(certificateChain);
+    if (!chain.leaf || !chain.intermediate) {
+        throw new Error('noise certificate chain is missing leaf/intermediate');
+    }
+    const intermediate = parseNoiseCertificate(chain.intermediate);
+    if (intermediate.issuerSerial !== constants_1.ROOT_CA_SERIAL) {
+        throw new Error('intermediate certificate issuer mismatch');
+    }
+    const rootKey = rootPublicKeySerialized();
+    const validIntermediate = await verifySignalVariant(rootKey, intermediate.details, intermediate.signature);
+    if (!validIntermediate) {
+        throw new Error('intermediate certificate signature is invalid');
+    }
+    const leaf = parseNoiseCertificate(chain.leaf);
+    if (leaf.issuerSerial !== intermediate.serial) {
+        throw new Error('leaf certificate issuer mismatch');
+    }
+    const intermediatePublicSerialized = (0, _crypto_1.toSerializedPubKey)(intermediate.key);
+    const validLeaf = await verifySignalVariant(intermediatePublicSerialized, leaf.details, leaf.signature);
+    if (!validLeaf) {
+        throw new Error('leaf certificate signature is invalid');
+    }
+    if (!(0, bytes_1.uint8Equal)(leaf.key, serverStatic)) {
+        throw new Error('leaf certificate key mismatch with server static key');
+    }
+}

package/dist/transport/noise/WaNoiseHandshake.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaNoiseHandshake = void 0;
+const _crypto_1 = require("../../crypto/index.js");
+const WaNoiseSocket_1 = require("../noise/WaNoiseSocket");
+const bytes_1 = require("../../util/bytes");
+class WaNoiseHandshake {
+    constructor() {
+        this.handshakeHash = bytes_1.EMPTY_BYTES;
+        this.chainingKey = bytes_1.EMPTY_BYTES;
+        this.cipherKey = null;
+        this.nonce = 0;
+    }
+    async start(protocolName, prologue) {
+        const hashInput = protocolName.length === 32 ? protocolName : await (0, _crypto_1.sha256)(protocolName);
+        this.handshakeHash = hashInput;
+        this.chainingKey = hashInput;
+        this.cipherKey = await (0, _crypto_1.importAesGcmKey)(this.handshakeHash, ['encrypt', 'decrypt']);
+        await this.authenticate(prologue);
+    }
+    async authenticate(data) {
+        this.handshakeHash = await (0, _crypto_1.sha256)((0, bytes_1.concatBytes)([this.handshakeHash, data]));
+    }
+    async mixIntoKey(keyMaterial) {
+        this.nonce = 0;
+        const [newChainingKey, nextCipherKey] = await (0, _crypto_1.hkdfSplit)(keyMaterial, this.chainingKey, '');
+        this.chainingKey = newChainingKey;
+        this.cipherKey = await (0, _crypto_1.importAesGcmKey)(nextCipherKey, ['encrypt', 'decrypt']);
+    }
+    async encrypt(plaintext) {
+        if (!this.cipherKey) {
+            throw new Error('noise handshake cipher key is not initialized');
+        }
+        const nonce = (0, _crypto_1.buildNonce)(this.nonce++);
+        const ciphertext = await (0, _crypto_1.aesGcmEncrypt)(this.cipherKey, nonce, plaintext, this.handshakeHash);
+        await this.authenticate(ciphertext);
+        return ciphertext;
+    }
+    async decrypt(ciphertext) {
+        if (!this.cipherKey) {
+            throw new Error('noise handshake cipher key is not initialized');
+        }
+        const nonce = (0, _crypto_1.buildNonce)(this.nonce++);
+        const plaintext = await (0, _crypto_1.aesGcmDecrypt)(this.cipherKey, nonce, ciphertext, this.handshakeHash);
+        await this.authenticate(ciphertext);
+        return plaintext;
+    }
+    async finish() {
+        const [writeKeyRaw, readKeyRaw] = await (0, _crypto_1.hkdfSplit)(bytes_1.EMPTY_BYTES, this.chainingKey, '');
+        const [writeKey, readKey] = await Promise.all([
+            (0, _crypto_1.importAesGcmKey)(writeKeyRaw, ['encrypt']),
+            (0, _crypto_1.importAesGcmKey)(readKeyRaw, ['decrypt'])
+        ]);
+        this.handshakeHash = bytes_1.EMPTY_BYTES;
+        this.chainingKey = bytes_1.EMPTY_BYTES;
+        this.cipherKey = null;
+        this.nonce = 0;
+        return new WaNoiseSocket_1.WaNoiseSocket(writeKey, readKey);
+    }
+}
+exports.WaNoiseHandshake = WaNoiseHandshake;