@waku/rln 0.1.3 → 0.1.4-2a94244.0

package/bundle/packages/rln/dist/keystore/keystore.js

@@ -0,0 +1,223 @@
+import '../../node_modules/@chainsafe/bls-keystore/lib/index.js';
+import '../../../interfaces/dist/protocols.js';
+import '../../../interfaces/dist/connection_manager.js';
+import '../../../interfaces/dist/health_indicator.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base10.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base16.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base2.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base32.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base36.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base58.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base64.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base8.js';
+import '../../../../node_modules/multiformats/dist/src/bases/identity.js';
+import '../../../../node_modules/multiformats/dist/src/codecs/json.js';
+import { Logger } from '../../../utils/dist/logger/index.js';
+import { sha256 } from '../../../../node_modules/ethereum-cryptography/esm/sha256.js';
+import { bytesToUtf8 } from '../../../../node_modules/ethereum-cryptography/esm/utils.js';
+import _ from '../../../../node_modules/lodash/lodash.js';
+import { buildBigIntFromUint8Array } from '../utils/bytes.js';
+import { keccak256Checksum, decryptEipKeystore } from './cipher.js';
+import { isKeystoreValid, isCredentialValid } from './schema_validator.js';
+import { __exports as lib } from '../../../../_virtual/index.js';
+import v4 from '../../node_modules/uuid/dist/esm-browser/v4.js';
+import { bytesToHex, utf8ToBytes } from '../../../../node_modules/@noble/hashes/esm/utils.js';
+
+const log = new Logger("waku:rln:keystore");
+class Keystore {
+    data;
+    constructor(options) {
+        this.data = Object.assign({
+            application: "waku-rln-relay",
+            appIdentifier: "01234567890abcdef",
+            version: "0.2",
+            credentials: {}
+        }, options);
+    }
+    static create(options = {}) {
+        return new Keystore(options);
+    }
+    // should be valid JSON string that contains Keystore file
+    // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/keyfile.nim#L376
+    static fromString(str) {
+        try {
+            const obj = JSON.parse(str);
+            if (!Keystore.isValidNwakuStore(obj)) {
+                throw Error("Invalid string, does not match Nwaku Keystore format.");
+            }
+            return new Keystore(obj);
+        }
+        catch (err) {
+            log.error("Cannot create Keystore from string:", err);
+            return;
+        }
+    }
+    static fromObject(obj) {
+        if (!Keystore.isValidNwakuStore(obj)) {
+            throw Error("Invalid object, does not match Nwaku Keystore format.");
+        }
+        return new Keystore(obj);
+    }
+    async addCredential(options, password) {
+        const membershipHash = Keystore.computeMembershipHash(options.membership);
+        if (this.data.credentials[membershipHash]) {
+            throw Error("Credential already exists in the store.");
+        }
+        // these are not important
+        const stubPath = "/stub/path";
+        const stubPubkey = new Uint8Array([0]);
+        const secret = Keystore.fromIdentityToBytes(options);
+        const eipKeystore = await lib.create(password, secret, stubPubkey, stubPath);
+        // need to re-compute checksum since nwaku uses keccak256 instead of sha256
+        const checksum = await keccak256Checksum(password, eipKeystore);
+        const nwakuCredential = Keystore.fromEipToCredential(eipKeystore, checksum);
+        this.data.credentials[membershipHash] = nwakuCredential;
+        return membershipHash;
+    }
+    async readCredential(membershipHash, password) {
+        const nwakuCredential = this.data.credentials[membershipHash];
+        if (!nwakuCredential) {
+            return;
+        }
+        const eipKeystore = Keystore.fromCredentialToEip(nwakuCredential);
+        const bytes = await decryptEipKeystore(password, eipKeystore);
+        return Keystore.fromBytesToIdentity(bytes);
+    }
+    removeCredential(hash) {
+        if (!this.data.credentials[hash]) {
+            return;
+        }
+        delete this.data.credentials[hash];
+    }
+    toString() {
+        return JSON.stringify(this.data);
+    }
+    toObject() {
+        return this.data;
+    }
+    /**
+     * Read array of hashes of current credentials
+     * @returns array of keys of credentials in current Keystore
+     */
+    keys() {
+        return Object.keys(this.toObject().credentials || {});
+    }
+    static isValidNwakuStore(obj) {
+        if (!isKeystoreValid(obj)) {
+            return false;
+        }
+        const areCredentialsValid = Object.values(_.get(obj, "credentials", {}))
+            .map((c) => isCredentialValid(c))
+            .every((v) => v);
+        return areCredentialsValid;
+    }
+    static fromCredentialToEip(credential) {
+        const nwakuCrypto = credential.crypto;
+        const eipCrypto = {
+            kdf: {
+                function: nwakuCrypto.kdf,
+                params: nwakuCrypto.kdfparams,
+                message: ""
+            },
+            cipher: {
+                function: nwakuCrypto.cipher,
+                params: nwakuCrypto.cipherparams,
+                message: nwakuCrypto.ciphertext
+            },
+            checksum: {
+                // @chainsafe/bls-keystore supports only sha256
+                // but nwaku uses keccak256
+                // https://github.com/waku-org/nwaku/blob/25d6e52e3804d15f9b61bc4cc6dd448540c072a1/waku/waku_keystore/keyfile.nim#L367
+                function: "sha256",
+                params: {},
+                message: nwakuCrypto.mac
+            }
+        };
+        return {
+            version: 4,
+            uuid: v4(),
+            description: undefined,
+            path: "safe to ignore, not important for decrypt",
+            pubkey: "safe to ignore, not important for decrypt",
+            crypto: eipCrypto
+        };
+    }
+    static fromEipToCredential(eipKeystore, checksum) {
+        const eipCrypto = eipKeystore.crypto;
+        const eipKdf = eipCrypto.kdf;
+        return {
+            crypto: {
+                cipher: eipCrypto.cipher.function,
+                cipherparams: eipCrypto.cipher.params,
+                ciphertext: eipCrypto.cipher.message,
+                kdf: eipKdf.function,
+                kdfparams: eipKdf.params,
+                // @chainsafe/bls-keystore generates only sha256
+                // but nwaku uses keccak256
+                // https://github.com/waku-org/nwaku/blob/25d6e52e3804d15f9b61bc4cc6dd448540c072a1/waku/waku_keystore/keyfile.nim#L367
+                mac: checksum
+            }
+        };
+    }
+    static fromBytesToIdentity(bytes) {
+        try {
+            const str = bytesToUtf8(bytes);
+            const obj = JSON.parse(str);
+            // TODO: add runtime validation of nwaku credentials
+            return {
+                identity: {
+                    IDCommitment: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idCommitment", [])),
+                    IDTrapdoor: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idTrapdoor", [])),
+                    IDNullifier: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idNullifier", [])),
+                    IDCommitmentBigInt: buildBigIntFromUint8Array(Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idCommitment", []))),
+                    IDSecretHash: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idSecretHash", []))
+                },
+                membership: {
+                    treeIndex: _.get(obj, "treeIndex"),
+                    chainId: _.get(obj, "membershipContract.chainId"),
+                    address: _.get(obj, "membershipContract.address")
+                }
+            };
+        }
+        catch (err) {
+            log.error("Cannot parse bytes to Nwaku Credentials:", err);
+            return;
+        }
+    }
+    static fromArraylikeToBytes(obj) {
+        const bytes = [];
+        let index = 0;
+        let lastElement = obj[index];
+        while (lastElement !== undefined) {
+            bytes.push(lastElement);
+            index += 1;
+            lastElement = obj[index];
+        }
+        return new Uint8Array(bytes);
+    }
+    // follows nwaku implementation
+    // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
+    static computeMembershipHash(info) {
+        return bytesToHex(sha256(utf8ToBytes(`${info.chainId}${info.address}${info.treeIndex}`))).toUpperCase();
+    }
+    // follows nwaku implementation
+    // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
+    static fromIdentityToBytes(options) {
+        return utf8ToBytes(JSON.stringify({
+            treeIndex: options.membership.treeIndex,
+            identityCredential: {
+                idCommitment: options.identity.IDCommitment,
+                idNullifier: options.identity.IDNullifier,
+                idSecretHash: options.identity.IDSecretHash,
+                idTrapdoor: options.identity.IDTrapdoor
+            },
+            membershipContract: {
+                chainId: options.membership.chainId,
+                address: options.membership.address
+            }
+        }));
+    }
+}
+
+export { Keystore };

package/bundle/packages/rln/dist/keystore/keystore_validation_generated.js

@@ -0,0 +1,74 @@
+/* eslint eslint-comments/no-unlimited-disable: "off" */
+// This file was generated by /scripts/schema-validation-codegen.ts
+// Do not modify this file by hand.
+/* eslint-disable */
+// @ts-ignore
+const Keystore = validate11;
+function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((((data.application === undefined) && (missing0 = "application")) || ((data.appIdentifier === undefined) && (missing0 = "appIdentifier"))) || ((data.credentials === undefined) && (missing0 = "credentials"))) || ((data.version === undefined) && (missing0 = "version"))) {
+            validate11.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            if (data.credentials !== undefined) {
+                let data0 = data.credentials;
+                const _errs1 = errors;
+                if (!(data0 && typeof data0 == "object" && !Array.isArray(data0))) {
+                    validate11.errors = [{ instancePath: instancePath + "/credentials", schemaPath: "#/properties/credentials/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+                var valid0 = _errs1 === errors;
+            }
+            else {
+                var valid0 = true;
+            }
+            if (valid0) {
+                if (data.appIdentifier !== undefined) {
+                    const _errs3 = errors;
+                    if (typeof data.appIdentifier !== "string") {
+                        validate11.errors = [{ instancePath: instancePath + "/appIdentifier", schemaPath: "#/properties/appIdentifier/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    var valid0 = _errs3 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.version !== undefined) {
+                        const _errs5 = errors;
+                        if (typeof data.version !== "string") {
+                            validate11.errors = [{ instancePath: instancePath + "/version", schemaPath: "#/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                        var valid0 = _errs5 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.application !== undefined) {
+                            const _errs7 = errors;
+                            if (typeof data.application !== "string") {
+                                validate11.errors = [{ instancePath: instancePath + "/application", schemaPath: "#/properties/application/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                            var valid0 = _errs7 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate11.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate11.errors = vErrors; return errors === 0; }
+
+export { Keystore };

package/bundle/packages/rln/dist/keystore/schema_validator.js

@@ -0,0 +1,20 @@
+import { Credential } from './credential_validation_generated.js';
+import { Keystore } from './keystore_validation_generated.js';
+
+const _validateKeystore = Keystore;
+const _validateCredential = Credential;
+function schemaValidationErrors(validator, data) {
+    const validated = validator(data);
+    if (validated) {
+        return null;
+    }
+    return validator.errors;
+}
+function isKeystoreValid(keystore) {
+    return !schemaValidationErrors(_validateKeystore, keystore);
+}
+function isCredentialValid(credential) {
+    return !schemaValidationErrors(_validateCredential, credential);
+}
+
+export { isCredentialValid, isKeystoreValid };

package/bundle/packages/rln/dist/message.js

@@ -0,0 +1,51 @@
+import { utf8ToBytes } from '../../utils/dist/bytes/index.js';
+import { epochBytesToInt } from './utils/epoch.js';
+
+function toRLNSignal(contentTopic, msg) {
+    const contentTopicBytes = utf8ToBytes(contentTopic ?? "");
+    return new Uint8Array([...(msg.payload ?? []), ...contentTopicBytes]);
+}
+class RlnMessage {
+    rlnInstance;
+    msg;
+    rateLimitProof;
+    pubsubTopic = "";
+    constructor(rlnInstance, msg, rateLimitProof) {
+        this.rlnInstance = rlnInstance;
+        this.msg = msg;
+        this.rateLimitProof = rateLimitProof;
+    }
+    verify(roots) {
+        return this.rateLimitProof
+            ? this.rlnInstance.zerokit.verifyWithRoots(this.rateLimitProof, toRLNSignal(this.msg.contentTopic, this.msg), roots) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
+            : undefined;
+    }
+    verifyNoRoot() {
+        return this.rateLimitProof
+            ? this.rlnInstance.zerokit.verifyWithNoRoot(this.rateLimitProof, toRLNSignal(this.msg.contentTopic, this.msg)) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
+            : undefined;
+    }
+    get payload() {
+        return this.msg.payload;
+    }
+    get contentTopic() {
+        return this.msg.contentTopic;
+    }
+    get timestamp() {
+        return this.msg.timestamp;
+    }
+    get ephemeral() {
+        return this.msg.ephemeral;
+    }
+    get meta() {
+        return this.msg.meta;
+    }
+    get epoch() {
+        const bytes = this.rateLimitProof?.epoch;
+        if (!bytes)
+            return undefined;
+        return epochBytesToInt(bytes);
+    }
+}
+
+export { RlnMessage, toRLNSignal };

package/bundle/packages/rln/dist/proof.js

@@ -0,0 +1,54 @@
+import { concatenate } from './utils/bytes.js';
+import { poseidonHash } from './utils/hash.js';
+import './utils/epoch.js';
+
+const proofOffset = 128;
+const rootOffset = proofOffset + 32;
+const epochOffset = rootOffset + 32;
+const shareXOffset = epochOffset + 32;
+const shareYOffset = shareXOffset + 32;
+const nullifierOffset = shareYOffset + 32;
+const rlnIdentifierOffset = nullifierOffset + 32;
+class ProofMetadata {
+    nullifier;
+    shareX;
+    shareY;
+    externalNullifier;
+    constructor(nullifier, shareX, shareY, externalNullifier) {
+        this.nullifier = nullifier;
+        this.shareX = shareX;
+        this.shareY = shareY;
+        this.externalNullifier = externalNullifier;
+    }
+}
+class Proof {
+    proof;
+    merkleRoot;
+    epoch;
+    shareX;
+    shareY;
+    nullifier;
+    rlnIdentifier;
+    constructor(proofBytes) {
+        if (proofBytes.length < rlnIdentifierOffset) {
+            throw new Error("invalid proof");
+        }
+        // parse the proof as proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32>
+        this.proof = proofBytes.subarray(0, proofOffset);
+        this.merkleRoot = proofBytes.subarray(proofOffset, rootOffset);
+        this.epoch = proofBytes.subarray(rootOffset, epochOffset);
+        this.shareX = proofBytes.subarray(epochOffset, shareXOffset);
+        this.shareY = proofBytes.subarray(shareXOffset, shareYOffset);
+        this.nullifier = proofBytes.subarray(shareYOffset, nullifierOffset);
+        this.rlnIdentifier = proofBytes.subarray(nullifierOffset, rlnIdentifierOffset);
+    }
+    extractMetadata() {
+        const externalNullifier = poseidonHash(this.epoch, this.rlnIdentifier);
+        return new ProofMetadata(this.nullifier, this.shareX, this.shareY, externalNullifier);
+    }
+}
+function proofToBytes(p) {
+    return concatenate(p.proof, p.merkleRoot, p.epoch, p.shareX, p.shareY, p.nullifier, p.rlnIdentifier);
+}
+
+export { Proof, proofToBytes };

package/bundle/packages/rln/dist/resources/verification_key.js

@@ -0,0 +1,112 @@
+const verificationKey = {
+  protocol: "groth16",
+  curve: "bn128",
+  nPublic: 6,
+  vk_alpha_1: [
+    "20124996762962216725442980738609010303800849578410091356605067053491763969391",
+    "9118593021526896828671519912099489027245924097793322973632351264852174143923",
+    "1"
+  ],
+  vk_beta_2: [
+    [
+      "4693952934005375501364248788849686435240706020501681709396105298107971354382",
+      "14346958885444710485362620645446987998958218205939139994511461437152241966681"
+    ],
+    [
+      "16851772916911573982706166384196538392731905827088356034885868448550849804972",
+      "823612331030938060799959717749043047845343400798220427319188951998582076532"
+    ],
+    ["1", "0"]
+  ],
+  vk_gamma_2: [
+    [
+      "10857046999023057135944570762232829481370756359578518086990519993285655852781",
+      "11559732032986387107991004021392285783925812861821192530917403151452391805634"
+    ],
+    [
+      "8495653923123431417604973247489272438418190587263600148770280649306958101930",
+      "4082367875863433681332203403145435568316851327593401208105741076214120093531"
+    ],
+    ["1", "0"]
+  ],
+  vk_delta_2: [
+    [
+      "8353516066399360694538747105302262515182301251524941126222712285088022964076",
+      "9329524012539638256356482961742014315122377605267454801030953882967973561832"
+    ],
+    [
+      "16805391589556134376869247619848130874761233086443465978238468412168162326401",
+      "10111259694977636294287802909665108497237922060047080343914303287629927847739"
+    ],
+    ["1", "0"]
+  ],
+  vk_alphabeta_12: [
+    [
+      [
+        "12608968655665301215455851857466367636344427685631271961542642719683786103711",
+        "9849575605876329747382930567422916152871921500826003490242628251047652318086"
+      ],
+      [
+        "6322029441245076030714726551623552073612922718416871603535535085523083939021",
+        "8700115492541474338049149013125102281865518624059015445617546140629435818912"
+      ],
+      [
+        "10674973475340072635573101639867487770811074181475255667220644196793546640210",
+        "2926286967251299230490668407790788696102889214647256022788211245826267484824"
+      ]
+    ],
+    [
+      [
+        "9660441540778523475944706619139394922744328902833875392144658911530830074820",
+        "19548113127774514328631808547691096362144426239827206966690021428110281506546"
+      ],
+      [
+        "1870837942477655969123169532603615788122896469891695773961478956740992497097",
+        "12536105729661705698805725105036536744930776470051238187456307227425796690780"
+      ],
+      [
+        "21811903352654147452884857281720047789720483752548991551595462057142824037334",
+        "19021616763967199151052893283384285352200445499680068407023236283004353578353"
+      ]
+    ]
+  ],
+  IC: [
+    [
+      "11992897507809711711025355300535923222599547639134311050809253678876341466909",
+      "17181525095924075896332561978747020491074338784673526378866503154966799128110",
+      "1"
+    ],
+    [
+      "17018665030246167677911144513385572506766200776123272044534328594850561667818",
+      "18601114175490465275436712413925513066546725461375425769709566180981674884464",
+      "1"
+    ],
+    [
+      "18799470100699658367834559797874857804183288553462108031963980039244731716542",
+      "13064227487174191981628537974951887429496059857753101852163607049188825592007",
+      "1"
+    ],
+    [
+      "17432501889058124609368103715904104425610382063762621017593209214189134571156",
+      "13406815149699834788256141097399354592751313348962590382887503595131085938635",
+      "1"
+    ],
+    [
+      "10320964835612716439094703312987075811498239445882526576970512041988148264481",
+      "9024164961646353611176283204118089412001502110138072989569118393359029324867",
+      "1"
+    ],
+    [
+      "718355081067365548229685160476620267257521491773976402837645005858953849298",
+      "14635482993933988261008156660773180150752190597753512086153001683711587601974",
+      "1"
+    ],
+    [
+      "11777720285956632126519898515392071627539405001940313098390150593689568177535",
+      "8483603647274280691250972408211651407952870456587066148445913156086740744515",
+      "1"
+    ]
+  ]
+};
+
+export { verificationKey as default };