@waku/core 0.0.1 → 0.0.2

package/bundle/lib/utils.js

@@ -1 +0,0 @@
-export { d as bytesToHex, g as bytesToUtf8, c as concat, h as hexToBytes, e as utf8ToBytes } from '../utils-9a3221f2.js';

package/bundle/lib/waku_message/version_1.js

@@ -1,463 +0,0 @@
-import { r as randomBytes, f as sha256, c as getPublicKey, h as getSubtle, i as getSharedSecret, S as Symmetric, k as keccak256, j as sign, l as Signature, m as recoverPublicKey } from '../../crypto-b00764b7.js';
-import { d as debug } from '../../browser-1e1a2f27.js';
-import { M as MessageV0, W as WakuMessage, D as DecoderV0 } from '../../version_0-e6fe440c.js';
-import { c as concat, h as hexToBytes } from '../../utils-9a3221f2.js';
-import '../../index-ba42b4fc.js';
-import '../../message-e2db79d7.js';
-
-/**
- * HKDF as implemented in go-ethereum.
- */
-function kdf(secret, outputLength) {
-    let ctr = 1;
-    let written = 0;
-    let willBeResult = Promise.resolve(new Uint8Array());
-    while (written < outputLength) {
-        const counters = new Uint8Array([ctr >> 24, ctr >> 16, ctr >> 8, ctr]);
-        const countersSecret = concat([counters, secret], counters.length + secret.length);
-        const willBeHashResult = sha256(countersSecret);
-        willBeResult = willBeResult.then((result) => willBeHashResult.then((hashResult) => {
-            const _hashResult = new Uint8Array(hashResult);
-            return concat([result, _hashResult], result.length + _hashResult.length);
-        }));
-        written += 32;
-        ctr += 1;
-    }
-    return willBeResult;
-}
-function aesCtrEncrypt(counter, key, data) {
-    return getSubtle()
-        .importKey("raw", key, "AES-CTR", false, ["encrypt"])
-        .then((cryptoKey) => getSubtle().encrypt({ name: "AES-CTR", counter: counter, length: 128 }, cryptoKey, data))
-        .then((bytes) => new Uint8Array(bytes));
-}
-function aesCtrDecrypt(counter, key, data) {
-    return getSubtle()
-        .importKey("raw", key, "AES-CTR", false, ["decrypt"])
-        .then((cryptoKey) => getSubtle().decrypt({ name: "AES-CTR", counter: counter, length: 128 }, cryptoKey, data))
-        .then((bytes) => new Uint8Array(bytes));
-}
-function hmacSha256Sign(key, msg) {
-    const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
-    return getSubtle()
-        .importKey("raw", key, algorithm, false, ["sign"])
-        .then((cryptoKey) => getSubtle().sign(algorithm, cryptoKey, msg))
-        .then((bytes) => new Uint8Array(bytes));
-}
-function hmacSha256Verify(key, msg, sig) {
-    const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
-    const _key = getSubtle().importKey("raw", key, algorithm, false, ["verify"]);
-    return _key.then((cryptoKey) => getSubtle().verify(algorithm, cryptoKey, sig, msg));
-}
-/**
- * Derive shared secret for given private and public keys.
- *
- * @param  privateKeyA Sender's private key (32 bytes)
- * @param  publicKeyB Recipient's public key (65 bytes)
- * @returns  A promise that resolves with the derived shared secret (Px, 32 bytes)
- * @throws Error If arguments are invalid
- */
-function derive(privateKeyA, publicKeyB) {
-    if (privateKeyA.length !== 32) {
-        throw new Error(`Bad private key, it should be 32 bytes but it's actually ${privateKeyA.length} bytes long`);
-    }
-    else if (publicKeyB.length !== 65) {
-        throw new Error(`Bad public key, it should be 65 bytes but it's actually ${publicKeyB.length} bytes long`);
-    }
-    else if (publicKeyB[0] !== 4) {
-        throw new Error("Bad public key, a valid public key would begin with 4");
-    }
-    else {
-        const px = getSharedSecret(privateKeyA, publicKeyB, true);
-        // Remove the compression prefix
-        return new Uint8Array(hexToBytes(px).slice(1));
-    }
-}
-/**
- * Encrypt message for given recipient's public key.
- *
- * @param  publicKeyTo Recipient's public key (65 bytes)
- * @param  msg The message being encrypted
- * @return A promise that resolves with the ECIES structure serialized
- */
-async function encrypt$1(publicKeyTo, msg) {
-    const ephemPrivateKey = randomBytes(32);
-    const sharedPx = await derive(ephemPrivateKey, publicKeyTo);
-    const hash = await kdf(sharedPx, 32);
-    const iv = randomBytes(16);
-    const encryptionKey = hash.slice(0, 16);
-    const cipherText = await aesCtrEncrypt(iv, encryptionKey, msg);
-    const ivCipherText = concat([iv, cipherText], iv.length + cipherText.length);
-    const macKey = await sha256(hash.slice(16));
-    const hmac = await hmacSha256Sign(macKey, ivCipherText);
-    const ephemPublicKey = getPublicKey(ephemPrivateKey, false);
-    return concat([ephemPublicKey, ivCipherText, hmac], ephemPublicKey.length + ivCipherText.length + hmac.length);
-}
-const metaLength = 1 + 64 + 16 + 32;
-/**
- * Decrypt message using given private key.
- *
- * @param privateKey A 32-byte private key of recipient of the message
- * @param encrypted ECIES serialized structure (result of ECIES encryption)
- * @returns The clear text
- * @throws Error If decryption fails
- */
-async function decrypt$1(privateKey, encrypted) {
-    if (encrypted.length <= metaLength) {
-        throw new Error(`Invalid Ciphertext. Data is too small. It should ba at least ${metaLength} bytes`);
-    }
-    else if (encrypted[0] !== 4) {
-        throw new Error(`Not a valid ciphertext. It should begin with 4 but actually begin with ${encrypted[0]}`);
-    }
-    else {
-        // deserialize
-        const ephemPublicKey = encrypted.slice(0, 65);
-        const cipherTextLength = encrypted.length - metaLength;
-        const iv = encrypted.slice(65, 65 + 16);
-        const cipherAndIv = encrypted.slice(65, 65 + 16 + cipherTextLength);
-        const ciphertext = cipherAndIv.slice(16);
-        const msgMac = encrypted.slice(65 + 16 + cipherTextLength);
-        // check HMAC
-        const px = derive(privateKey, ephemPublicKey);
-        const hash = await kdf(px, 32);
-        const [encryptionKey, macKey] = await sha256(hash.slice(16)).then((macKey) => [hash.slice(0, 16), macKey]);
-        if (!(await hmacSha256Verify(macKey, cipherAndIv, msgMac))) {
-            throw new Error("Incorrect MAC");
-        }
-        return aesCtrDecrypt(iv, encryptionKey, ciphertext);
-    }
-}
-
-async function encrypt(iv, key, clearText) {
-    return getSubtle()
-        .importKey("raw", key, Symmetric.algorithm, false, ["encrypt"])
-        .then((cryptoKey) => getSubtle().encrypt({ iv, ...Symmetric.algorithm }, cryptoKey, clearText))
-        .then((cipher) => new Uint8Array(cipher));
-}
-async function decrypt(iv, key, cipherText) {
-    return getSubtle()
-        .importKey("raw", key, Symmetric.algorithm, false, ["decrypt"])
-        .then((cryptoKey) => getSubtle().decrypt({ iv, ...Symmetric.algorithm }, cryptoKey, cipherText))
-        .then((clear) => new Uint8Array(clear));
-}
-function generateIv() {
-    return randomBytes(Symmetric.ivSize);
-}
-
-const log = debug("waku:message:version-1");
-const FlagsLength = 1;
-const FlagMask = 3; // 0011
-const IsSignedMask = 4; // 0100
-const PaddingTarget = 256;
-const SignatureLength = 65;
-const OneMillion = BigInt(1000000);
-const Version = 1;
-class MessageV1 extends MessageV0 {
-    constructor(proto, decodedPayload, signature, signaturePublicKey) {
-        super(proto);
-        this.signature = signature;
-        this.signaturePublicKey = signaturePublicKey;
-        this._decodedPayload = decodedPayload;
-    }
-    get payload() {
-        return this._decodedPayload;
-    }
-}
-class AsymEncoder {
-    constructor(contentTopic, publicKey, sigPrivKey) {
-        this.contentTopic = contentTopic;
-        this.publicKey = publicKey;
-        this.sigPrivKey = sigPrivKey;
-    }
-    async toWire(message$1) {
-        const protoMessage = await this.toProtoObj(message$1);
-        if (!protoMessage)
-            return;
-        return WakuMessage.encode(protoMessage);
-    }
-    async toProtoObj(message) {
-        const timestamp = message.timestamp ?? new Date();
-        if (!message.payload) {
-            log("No payload to encrypt, skipping: ", message);
-            return;
-        }
-        const preparedPayload = await preCipher(message.payload, this.sigPrivKey);
-        const payload = await encryptAsymmetric(preparedPayload, this.publicKey);
-        return {
-            payload,
-            version: Version,
-            contentTopic: this.contentTopic,
-            timestamp: BigInt(timestamp.valueOf()) * OneMillion,
-            rateLimitProof: message.rateLimitProof,
-        };
-    }
-}
-class SymEncoder {
-    constructor(contentTopic, symKey, sigPrivKey) {
-        this.contentTopic = contentTopic;
-        this.symKey = symKey;
-        this.sigPrivKey = sigPrivKey;
-    }
-    async toWire(message$1) {
-        const protoMessage = await this.toProtoObj(message$1);
-        if (!protoMessage)
-            return;
-        return WakuMessage.encode(protoMessage);
-    }
-    async toProtoObj(message) {
-        const timestamp = message.timestamp ?? new Date();
-        if (!message.payload) {
-            log("No payload to encrypt, skipping: ", message);
-            return;
-        }
-        const preparedPayload = await preCipher(message.payload, this.sigPrivKey);
-        const payload = await encryptSymmetric(preparedPayload, this.symKey);
-        return {
-            payload,
-            version: Version,
-            contentTopic: this.contentTopic,
-            timestamp: BigInt(timestamp.valueOf()) * OneMillion,
-            rateLimitProof: message.rateLimitProof,
-        };
-    }
-}
-class AsymDecoder extends DecoderV0 {
-    constructor(contentTopic, privateKey) {
-        super(contentTopic);
-        this.privateKey = privateKey;
-    }
-    async fromProtoObj(protoMessage) {
-        const cipherPayload = protoMessage.payload;
-        if (protoMessage.version !== Version) {
-            log("Failed to decrypt due to incorrect version, expected:", Version, ", actual:", protoMessage.version);
-            return;
-        }
-        let payload;
-        if (!cipherPayload) {
-            log(`No payload to decrypt for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        try {
-            payload = await decryptAsymmetric(cipherPayload, this.privateKey);
-        }
-        catch (e) {
-            log(`Failed to decrypt message using asymmetric decryption for contentTopic: ${this.contentTopic}`, e);
-            return;
-        }
-        if (!payload) {
-            log(`Failed to decrypt payload for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        const res = await postCipher(payload);
-        if (!res) {
-            log(`Failed to decode payload for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        log("Message decrypted", protoMessage);
-        return new MessageV1(protoMessage, res.payload, res.sig?.signature, res.sig?.publicKey);
-    }
-}
-class SymDecoder extends DecoderV0 {
-    constructor(contentTopic, symKey) {
-        super(contentTopic);
-        this.symKey = symKey;
-    }
-    async fromProtoObj(protoMessage) {
-        const cipherPayload = protoMessage.payload;
-        if (protoMessage.version !== Version) {
-            log("Failed to decrypt due to incorrect version, expected:", Version, ", actual:", protoMessage.version);
-            return;
-        }
-        let payload;
-        if (!cipherPayload) {
-            log(`No payload to decrypt for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        try {
-            payload = await decryptSymmetric(cipherPayload, this.symKey);
-        }
-        catch (e) {
-            log(`Failed to decrypt message using asymmetric decryption for contentTopic: ${this.contentTopic}`, e);
-            return;
-        }
-        if (!payload) {
-            log(`Failed to decrypt payload for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        const res = await postCipher(payload);
-        if (!res) {
-            log(`Failed to decode payload for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        log("Message decrypted", protoMessage);
-        return new MessageV1(protoMessage, res.payload, res.sig?.signature, res.sig?.publicKey);
-    }
-}
-function getSizeOfPayloadSizeField(message) {
-    const messageDataView = new DataView(message.buffer);
-    return messageDataView.getUint8(0) & FlagMask;
-}
-function getPayloadSize(message, sizeOfPayloadSizeField) {
-    let payloadSizeBytes = message.slice(1, 1 + sizeOfPayloadSizeField);
-    // int 32 == 4 bytes
-    if (sizeOfPayloadSizeField < 4) {
-        // If less than 4 bytes pad right (Little Endian).
-        payloadSizeBytes = concat([payloadSizeBytes, new Uint8Array(4 - sizeOfPayloadSizeField)], 4);
-    }
-    const payloadSizeDataView = new DataView(payloadSizeBytes.buffer);
-    return payloadSizeDataView.getInt32(0, true);
-}
-function isMessageSigned(message) {
-    const messageDataView = new DataView(message.buffer);
-    return (messageDataView.getUint8(0) & IsSignedMask) == IsSignedMask;
-}
-/**
- * Proceed with Asymmetric encryption of the data as per [26/WAKU-PAYLOAD](https://rfc.vac.dev/spec/26/).
- * The data MUST be flags | payload-length | payload | [signature].
- * The returned result  can be set to `WakuMessage.payload`.
- *
- * @internal
- */
-async function encryptAsymmetric(data, publicKey) {
-    return encrypt$1(hexToBytes(publicKey), data);
-}
-/**
- * Proceed with Asymmetric decryption of the data as per [26/WAKU-PAYLOAD](https://rfc.vac.dev/spec/26/).
- * The returned data is expected to be `flags | payload-length | payload | [signature]`.
- *
- * @internal
- */
-async function decryptAsymmetric(payload, privKey) {
-    return decrypt$1(privKey, payload);
-}
-/**
- * Proceed with Symmetric encryption of the data as per [26/WAKU-PAYLOAD](https://rfc.vac.dev/spec/26/).
- *
- * @param data The data to encrypt, expected to be `flags | payload-length | payload | [signature]`.
- * @param key The key to use for encryption.
- * @returns The decrypted data, `cipherText | tag | iv` and can be set to `WakuMessage.payload`.
- *
- * @internal
- */
-async function encryptSymmetric(data, key) {
-    const iv = generateIv();
-    // Returns `cipher | tag`
-    const cipher = await encrypt(iv, hexToBytes(key), data);
-    return concat([cipher, iv]);
-}
-/**
- * Proceed with Symmetric decryption of the data as per [26/WAKU-PAYLOAD](https://rfc.vac.dev/spec/26/).
- *
- * @param payload The cipher data, it is expected to be `cipherText | tag | iv`.
- * @param key The key to use for decryption.
- * @returns The decrypted data, expected to be `flags | payload-length | payload | [signature]`.
- *
- * @internal
- */
-async function decryptSymmetric(payload, key) {
-    const ivStart = payload.length - Symmetric.ivSize;
-    const cipher = payload.slice(0, ivStart);
-    const iv = payload.slice(ivStart);
-    return decrypt(iv, hexToBytes(key), cipher);
-}
-/**
- * Computes the flags & auxiliary-field as per [26/WAKU-PAYLOAD](https://rfc.vac.dev/spec/26/).
- */
-function addPayloadSizeField(msg, payload) {
-    const fieldSize = computeSizeOfPayloadSizeField(payload);
-    let field = new Uint8Array(4);
-    const fieldDataView = new DataView(field.buffer);
-    fieldDataView.setUint32(0, payload.length, true);
-    field = field.slice(0, fieldSize);
-    msg = concat([msg, field]);
-    msg[0] |= fieldSize;
-    return msg;
-}
-/**
- * Returns the size of the auxiliary-field which in turns contains the payload size
- */
-function computeSizeOfPayloadSizeField(payload) {
-    let s = 1;
-    for (let i = payload.length; i >= 256; i /= 256) {
-        s++;
-    }
-    return s;
-}
-function validateDataIntegrity(value, expectedSize) {
-    if (value.length !== expectedSize) {
-        return false;
-    }
-    return expectedSize <= 3 || value.findIndex((i) => i !== 0) !== -1;
-}
-function getSignature(message) {
-    return message.slice(message.length - SignatureLength, message.length);
-}
-function getHash(message, isSigned) {
-    if (isSigned) {
-        return keccak256(message.slice(0, message.length - SignatureLength));
-    }
-    return keccak256(message);
-}
-function ecRecoverPubKey(messageHash, signature) {
-    const recoveryDataView = new DataView(signature.slice(64).buffer);
-    const recovery = recoveryDataView.getUint8(0);
-    const _signature = Signature.fromCompact(signature.slice(0, 64));
-    return recoverPublicKey(messageHash, _signature, recovery, false);
-}
-/**
- * Prepare the payload pre-encryption.
- *
- * @internal
- * @returns The encoded payload, ready for encryption using {@link encryptAsymmetric}
- * or {@link encryptSymmetric}.
- */
-async function preCipher(messagePayload, sigPrivKey) {
-    let envelope = new Uint8Array([0]); // No flags
-    envelope = addPayloadSizeField(envelope, messagePayload);
-    envelope = concat([envelope, messagePayload]);
-    // Calculate padding:
-    let rawSize = FlagsLength +
-        computeSizeOfPayloadSizeField(messagePayload) +
-        messagePayload.length;
-    if (sigPrivKey) {
-        rawSize += SignatureLength;
-    }
-    const remainder = rawSize % PaddingTarget;
-    const paddingSize = PaddingTarget - remainder;
-    const pad = randomBytes(paddingSize);
-    if (!validateDataIntegrity(pad, paddingSize)) {
-        throw new Error("failed to generate random padding of size " + paddingSize);
-    }
-    envelope = concat([envelope, pad]);
-    if (sigPrivKey) {
-        envelope[0] |= IsSignedMask;
-        const hash = keccak256(envelope);
-        const bytesSignature = await sign(hash, sigPrivKey);
-        envelope = concat([envelope, bytesSignature]);
-    }
-    return envelope;
-}
-/**
- * Decode a decrypted payload.
- *
- * @internal
- */
-function postCipher(message) {
-    const sizeOfPayloadSizeField = getSizeOfPayloadSizeField(message);
-    if (sizeOfPayloadSizeField === 0)
-        return;
-    const payloadSize = getPayloadSize(message, sizeOfPayloadSizeField);
-    const payloadStart = 1 + sizeOfPayloadSizeField;
-    const payload = message.slice(payloadStart, payloadStart + payloadSize);
-    const isSigned = isMessageSigned(message);
-    let sig;
-    if (isSigned) {
-        const signature = getSignature(message);
-        const hash = getHash(message, isSigned);
-        const publicKey = ecRecoverPubKey(hash, signature);
-        sig = { signature, publicKey };
-    }
-    return { payload, sig };
-}
-
-export { AsymDecoder, AsymEncoder, MessageV1, SymDecoder, SymEncoder, Version, decryptAsymmetric, decryptSymmetric, encryptAsymmetric, encryptSymmetric, postCipher, preCipher };

package/bundle/multiaddr_to_peer_info-c406b1e1.js

@@ -1,19 +0,0 @@
-import { p as peerIdFromString } from './events-158407bb.js';
-
-const symbol = Symbol.for('@libp2p/peer-discovery');
-
-function multiaddrsToPeerInfo(mas) {
-    return mas
-        .map((ma) => {
-        const peerIdStr = ma.getPeerId();
-        const protocols = [];
-        return {
-            id: peerIdStr ? peerIdFromString(peerIdStr) : null,
-            multiaddrs: [ma.decapsulateCode(421)],
-            protocols,
-        };
-    })
-        .filter((peerInfo) => peerInfo.id !== null);
-}
-
-export { multiaddrsToPeerInfo as m, symbol as s };

package/bundle/multiaddr_to_peer_info-fd1de516.js

@@ -1,19 +0,0 @@
-import { p as peerIdFromString } from './index-2ae915be.js';
-
-const symbol = Symbol.for('@libp2p/peer-discovery');
-
-function multiaddrsToPeerInfo(mas) {
-    return mas
-        .map((ma) => {
-        const peerIdStr = ma.getPeerId();
-        const protocols = [];
-        return {
-            id: peerIdStr ? peerIdFromString(peerIdStr) : null,
-            multiaddrs: [ma.decapsulateCode(421)],
-            protocols,
-        };
-    })
-        .filter((peerInfo) => peerInfo.id !== null);
-}
-
-export { multiaddrsToPeerInfo as m, symbol as s };