@waku/rln 0.0.1 → 0.0.2-00f2e75.0

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

@@ -0,0 +1,31 @@
+import { cipherDecrypt as cipherDecrypt_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/cipher.js';
+import { kdf as kdf_2 } from '../../node_modules/@chainsafe/bls-keystore/lib/kdf.js';
+import { normalizePassword as normalizePassword_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/password.js';
+import { keccak256 } from '../../../../node_modules/ethereum-cryptography/esm/keccak.js';
+import { hexToBytes } from '../../../../node_modules/ethereum-cryptography/esm/utils.js';
+import { concatBytes, bytesToHex } from '../../../../node_modules/@noble/hashes/esm/utils.js';
+
+// eipKeystore supports only sha256 checksum so we just make an assumption it is keccak256
+const validateChecksum = async (password, eipKeystore) => {
+    const computedChecksum = await keccak256Checksum(password, eipKeystore);
+    return computedChecksum === eipKeystore.crypto.checksum.message;
+};
+// decrypt from @chainsafe/bls-keystore supports only sha256
+// but nwaku uses keccak256
+// https://github.com/waku-org/nwaku/blob/25d6e52e3804d15f9b61bc4cc6dd448540c072a1/waku/waku_keystore/keyfile.nim#L367
+const decryptEipKeystore = async (password, eipKeystore) => {
+    const decryptionKey = await kdf_2(eipKeystore.crypto.kdf, normalizePassword_1(password));
+    const isChecksumValid = await validateChecksum(password, eipKeystore);
+    if (!isChecksumValid) {
+        throw Error("Password is invalid.");
+    }
+    return cipherDecrypt_1(eipKeystore.crypto.cipher, decryptionKey.slice(0, 16));
+};
+const keccak256Checksum = async (password, eipKeystore) => {
+    const key = await kdf_2(eipKeystore.crypto.kdf, normalizePassword_1(password));
+    const payload = concatBytes(key.slice(16), hexToBytes(eipKeystore.crypto.cipher.message));
+    const ciphertext = keccak256(payload);
+    return bytesToHex(ciphertext);
+};
+
+export { decryptEipKeystore, keccak256Checksum };

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

@@ -0,0 +1,119 @@
+/* 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 Credential = 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.crypto === undefined) && (missing0 = "crypto")) {
+            validate11.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            if (data.crypto !== undefined) {
+                let data0 = data.crypto;
+                {
+                    if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                        let missing1;
+                        if (((((((data0.cipher === undefined) && (missing1 = "cipher")) || ((data0.cipherparams === undefined) && (missing1 = "cipherparams"))) || ((data0.ciphertext === undefined) && (missing1 = "ciphertext"))) || ((data0.kdf === undefined) && (missing1 = "kdf"))) || ((data0.kdfparams === undefined) && (missing1 = "kdfparams"))) || ((data0.mac === undefined) && (missing1 = "mac"))) {
+                            validate11.errors = [{ instancePath: instancePath + "/crypto", schemaPath: "#/properties/crypto/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                            return false;
+                        }
+                        else {
+                            if (data0.cipher !== undefined) {
+                                const _errs3 = errors;
+                                if (typeof data0.cipher !== "string") {
+                                    validate11.errors = [{ instancePath: instancePath + "/crypto/cipher", schemaPath: "#/properties/crypto/properties/cipher/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                                var valid1 = _errs3 === errors;
+                            }
+                            else {
+                                var valid1 = true;
+                            }
+                            if (valid1) {
+                                if (data0.cipherparams !== undefined) {
+                                    let data2 = data0.cipherparams;
+                                    const _errs5 = errors;
+                                    if (!(data2 && typeof data2 == "object" && !Array.isArray(data2))) {
+                                        validate11.errors = [{ instancePath: instancePath + "/crypto/cipherparams", schemaPath: "#/properties/crypto/properties/cipherparams/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                        return false;
+                                    }
+                                    var valid1 = _errs5 === errors;
+                                }
+                                else {
+                                    var valid1 = true;
+                                }
+                                if (valid1) {
+                                    if (data0.ciphertext !== undefined) {
+                                        const _errs7 = errors;
+                                        if (typeof data0.ciphertext !== "string") {
+                                            validate11.errors = [{ instancePath: instancePath + "/crypto/ciphertext", schemaPath: "#/properties/crypto/properties/ciphertext/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                            return false;
+                                        }
+                                        var valid1 = _errs7 === errors;
+                                    }
+                                    else {
+                                        var valid1 = true;
+                                    }
+                                    if (valid1) {
+                                        if (data0.kdf !== undefined) {
+                                            const _errs9 = errors;
+                                            if (typeof data0.kdf !== "string") {
+                                                validate11.errors = [{ instancePath: instancePath + "/crypto/kdf", schemaPath: "#/properties/crypto/properties/kdf/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                return false;
+                                            }
+                                            var valid1 = _errs9 === errors;
+                                        }
+                                        else {
+                                            var valid1 = true;
+                                        }
+                                        if (valid1) {
+                                            if (data0.kdfparams !== undefined) {
+                                                let data5 = data0.kdfparams;
+                                                const _errs11 = errors;
+                                                if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
+                                                    validate11.errors = [{ instancePath: instancePath + "/crypto/kdfparams", schemaPath: "#/properties/crypto/properties/kdfparams/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                                var valid1 = _errs11 === errors;
+                                            }
+                                            else {
+                                                var valid1 = true;
+                                            }
+                                            if (valid1) {
+                                                if (data0.mac !== undefined) {
+                                                    const _errs13 = errors;
+                                                    if (typeof data0.mac !== "string") {
+                                                        validate11.errors = [{ instancePath: instancePath + "/crypto/mac", schemaPath: "#/properties/crypto/properties/mac/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    var valid1 = _errs13 === errors;
+                                                }
+                                                else {
+                                                    var valid1 = true;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        validate11.errors = [{ instancePath: instancePath + "/crypto", schemaPath: "#/properties/crypto/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate11.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate11.errors = vErrors; return errors === 0; }
+
+export { Credential };

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 };