@waku/rln 0.1.5-861a776.0 → 0.1.5-a824fff.0

package/src/rln.ts

@@ -7,7 +7,6 @@ import type {
 import { Logger } from "@waku/utils";
 import init from "@waku/zerokit-rln-wasm";
 import * as zerokitRLN from "@waku/zerokit-rln-wasm";
-import { ethers } from "ethers";
 
 import {
   createRLNDecoder,
@@ -16,258 +15,52 @@ import {
   type RLNEncoder
 } from "./codec.js";
 import { DEFAULT_RATE_LIMIT } from "./contract/constants.js";
-import { LINEA_CONTRACT, RLNContract } from "./contract/index.js";
-import { IdentityCredential } from "./identity.js";
-import { Keystore } from "./keystore/index.js";
+import { RLNCredentialsManager } from "./credentials_manager.js";
 import type {
   DecryptedCredentials,
   EncryptedCredentials
 } from "./keystore/index.js";
-import { KeystoreEntity, Password } from "./keystore/types.js";
 import verificationKey from "./resources/verification_key";
 import * as wc from "./resources/witness_calculator";
 import { WitnessCalculator } from "./resources/witness_calculator";
-import { extractMetaMaskSigner } from "./utils/index.js";
 import { Zerokit } from "./zerokit.js";
 
 const log = new Logger("waku:rln");
 
-async function loadWitnessCalculator(): Promise<WitnessCalculator> {
-  try {
-    const url = new URL("./resources/rln.wasm", import.meta.url);
-    const response = await fetch(url);
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch witness calculator: ${response.status} ${response.statusText}`
-      );
-    }
-
-    return await wc.builder(
-      new Uint8Array(await response.arrayBuffer()),
-      false
-    );
-  } catch (error) {
-    log.error("Error loading witness calculator:", error);
-    throw new Error(
-      `Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-
-async function loadZkey(): Promise<Uint8Array> {
-  try {
-    const url = new URL("./resources/rln_final.zkey", import.meta.url);
-    const response = await fetch(url);
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch zkey: ${response.status} ${response.statusText}`
-      );
-    }
-
-    return new Uint8Array(await response.arrayBuffer());
-  } catch (error) {
-    log.error("Error loading zkey:", error);
-    throw new Error(
-      `Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-
-/**
- * Create an instance of RLN
- * @returns RLNInstance
- */
-export async function create(): Promise<RLNInstance> {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await (init as any)?.();
-    zerokitRLN.init_panic_hook();
-
-    const witnessCalculator = await loadWitnessCalculator();
-    const zkey = await loadZkey();
-
-    const stringEncoder = new TextEncoder();
-    const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
-
-    const DEPTH = 20;
-    const zkRLN = zerokitRLN.newRLN(DEPTH, zkey, vkey);
-    const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
-
-    return new RLNInstance(zerokit);
-  } catch (error) {
-    log.error("Failed to initialize RLN:", error);
-    throw error;
-  }
-}
-
-type StartRLNOptions = {
-  /**
-   * If not set - will extract MetaMask account and get signer from it.
-   */
-  signer?: ethers.Signer;
-  /**
-   * If not set - will use default LINEA_CONTRACT address.
-   */
-  address?: string;
-  /**
-   * Credentials to use for generating proofs and connecting to the contract and network.
-   * If provided used for validating the network chainId and connecting to registry contract.
-   */
-  credentials?: EncryptedCredentials | DecryptedCredentials;
-  /**
-   * Rate limit for the member.
-   */
-  rateLimit?: number;
-};
-
-type RegisterMembershipOptions =
-  | { signature: string }
-  | { identity: IdentityCredential };
-
 type WakuRLNEncoderOptions = WakuEncoderOptions & {
   credentials: EncryptedCredentials | DecryptedCredentials;
 };
 
-export class RLNInstance {
-  private started = false;
-  private starting = false;
-
-  private _contract: undefined | RLNContract;
-  private _signer: undefined | ethers.Signer;
-
-  private keystore = Keystore.create();
-  private _credentials: undefined | DecryptedCredentials;
-
-  public constructor(public zerokit: Zerokit) {}
-
-  public get contract(): undefined | RLNContract {
-    return this._contract;
-  }
-
-  public get signer(): undefined | ethers.Signer {
-    return this._signer;
-  }
-
-  public async start(options: StartRLNOptions = {}): Promise<void> {
-    if (this.started || this.starting) {
-      return;
-    }
-
-    this.starting = true;
-
+export class RLNInstance extends RLNCredentialsManager {
+  /**
+   * Create an instance of RLN
+   * @returns RLNInstance
+   */
+  public static async create(): Promise<RLNInstance> {
     try {
-      const { credentials, keystore } =
-        await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-      const { signer, address, rateLimit } = await this.determineStartOptions(
-        options,
-        credentials
-      );
-
-      if (keystore) {
-        this.keystore = keystore;
-      }
-
-      this._credentials = credentials;
-      this._signer = signer!;
-      this._contract = await RLNContract.init(this, {
-        address: address!,
-        signer: signer!,
-        rateLimit: rateLimit ?? this.zerokit.getRateLimit
-      });
-      this.started = true;
-    } finally {
-      this.starting = false;
-    }
-  }
-
-  private async determineStartOptions(
-    options: StartRLNOptions,
-    credentials: KeystoreEntity | undefined
-  ): Promise<StartRLNOptions> {
-    let chainId = credentials?.membership.chainId;
-    const address =
-      credentials?.membership.address ||
-      options.address ||
-      LINEA_CONTRACT.address;
-
-    if (address === LINEA_CONTRACT.address) {
-      chainId = LINEA_CONTRACT.chainId;
-    }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await (init as any)?.();
+      zerokitRLN.init_panic_hook();
 
-    const signer = options.signer || (await extractMetaMaskSigner());
-    const currentChainId = (await signer.getChainId()).toString();
+      const witnessCalculator = await RLNInstance.loadWitnessCalculator();
+      const zkey = await RLNInstance.loadZkey();
 
-    if (chainId && chainId !== currentChainId) {
-      throw Error(
-        `Failed to start RLN contract, chain ID of contract is different from current one: contract-${chainId}, current network-${currentChainId}`
-      );
-    }
-
-    return {
-      signer,
-      address
-    };
-  }
-
-  private static async decryptCredentialsIfNeeded(
-    credentials?: EncryptedCredentials | DecryptedCredentials
-  ): Promise<{ credentials?: DecryptedCredentials; keystore?: Keystore }> {
-    if (!credentials) {
-      return {};
-    }
-
-    if ("identity" in credentials) {
-      return { credentials };
-    }
-
-    const keystore = Keystore.fromString(credentials.keystore);
-
-    if (!keystore) {
-      return {};
-    }
-
-    const decryptedCredentials = await keystore.readCredential(
-      credentials.id,
-      credentials.password
-    );
+      const stringEncoder = new TextEncoder();
+      const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
 
-    return {
-      keystore,
-      credentials: decryptedCredentials
-    };
-  }
-
-  public async registerMembership(
-    options: RegisterMembershipOptions
-  ): Promise<undefined | DecryptedCredentials> {
-    if (!this.contract) {
-      throw Error("RLN Contract is not initialized.");
-    }
-
-    let identity = "identity" in options && options.identity;
-
-    if ("signature" in options) {
-      identity = this.zerokit.generateSeededIdentityCredential(
-        options.signature
-      );
-    }
+      const DEPTH = 20;
+      const zkRLN = zerokitRLN.newRLN(DEPTH, zkey, vkey);
+      const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
 
-    if (!identity) {
-      throw Error("Missing signature or identity to register membership.");
+      return new RLNInstance(zerokit);
+    } catch (error) {
+      log.error("Failed to initialize RLN:", error);
+      throw error;
     }
-
-    return this.contract.registerWithIdentity(identity);
   }
 
-  /**
-   * Changes credentials in use by relying on provided Keystore earlier in rln.start
-   * @param id: string, hash of credentials to select from Keystore
-   * @param password: string or bytes to use to decrypt credentials from Keystore
-   */
-  public async useCredentials(id: string, password: Password): Promise<void> {
-    this._credentials = await this.keystore?.readCredential(id, password);
+  private constructor(public zerokit: Zerokit) {
+    super(zerokit);
   }
 
   public async createEncoder(
@@ -275,7 +68,7 @@ export class RLNInstance {
   ): Promise<RLNEncoder> {
     const { credentials: decryptedCredentials } =
       await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-    const credentials = decryptedCredentials || this._credentials;
+    const credentials = decryptedCredentials || this.credentials;
 
     if (!credentials) {
       throw Error(
@@ -293,33 +86,6 @@ export class RLNInstance {
     });
   }
 
-  private async verifyCredentialsAgainstContract(
-    credentials: KeystoreEntity
-  ): Promise<void> {
-    if (!this._contract) {
-      throw Error(
-        "Failed to verify chain coordinates: no contract initialized."
-      );
-    }
-
-    const registryAddress = credentials.membership.address;
-    const currentRegistryAddress = this._contract.address;
-    if (registryAddress !== currentRegistryAddress) {
-      throw Error(
-        `Failed to verify chain coordinates: credentials contract address=${registryAddress} is not equal to registryContract address=${currentRegistryAddress}`
-      );
-    }
-
-    const chainId = credentials.membership.chainId;
-    const network = await this._contract.provider.getNetwork();
-    const currentChainId = network.chainId.toString();
-    if (chainId !== currentChainId) {
-      throw Error(
-        `Failed to verify chain coordinates: credentials chainID=${chainId} is not equal to registryContract chainID=${currentChainId}`
-      );
-    }
-  }
-
   public createDecoder(
     contentTopic: ContentTopic
   ): RLNDecoder<IDecodedMessage> {
@@ -328,4 +94,47 @@ export class RLNInstance {
       decoder: createDecoder(contentTopic)
     });
   }
+
+  public static async loadWitnessCalculator(): Promise<WitnessCalculator> {
+    try {
+      const url = new URL("./resources/rln.wasm", import.meta.url);
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch witness calculator: ${response.status} ${response.statusText}`
+        );
+      }
+
+      return await wc.builder(
+        new Uint8Array(await response.arrayBuffer()),
+        false
+      );
+    } catch (error) {
+      log.error("Error loading witness calculator:", error);
+      throw new Error(
+        `Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  public static async loadZkey(): Promise<Uint8Array> {
+    try {
+      const url = new URL("./resources/rln_final.zkey", import.meta.url);
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch zkey: ${response.status} ${response.statusText}`
+        );
+      }
+
+      return new Uint8Array(await response.arrayBuffer());
+    } catch (error) {
+      log.error("Error loading zkey:", error);
+      throw new Error(
+        `Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
 }

package/src/types.ts

@@ -0,0 +1,31 @@
+import { ethers } from "ethers";
+
+import { IdentityCredential } from "./identity.js";
+import {
+  DecryptedCredentials,
+  EncryptedCredentials
+} from "./keystore/types.js";
+
+export type StartRLNOptions = {
+  /**
+   * If not set - will extract MetaMask account and get signer from it.
+   */
+  signer?: ethers.Signer;
+  /**
+   * If not set - will use default SEPOLIA_CONTRACT address.
+   */
+  address?: string;
+  /**
+   * Credentials to use for generating proofs and connecting to the contract and network.
+   * If provided used for validating the network chainId and connecting to registry contract.
+   */
+  credentials?: EncryptedCredentials | DecryptedCredentials;
+  /**
+   * Rate limit for the member.
+   */
+  rateLimit?: number;
+};
+
+export type RegisterMembershipOptions =
+  | { signature: string }
+  | { identity: IdentityCredential };

package/src/zerokit.ts

@@ -16,7 +16,7 @@ export class Zerokit {
   public constructor(
     private readonly zkRLN: number,
     private readonly witnessCalculator: WitnessCalculator,
-    private readonly rateLimit: number = DEFAULT_RATE_LIMIT
+    private readonly _rateLimit: number = DEFAULT_RATE_LIMIT
   ) {}
 
   public get getZkRLN(): number {
@@ -27,8 +27,8 @@ export class Zerokit {
     return this.witnessCalculator;
   }
 
-  public get getRateLimit(): number {
-    return this.rateLimit;
+  public get rateLimit(): number {
+    return this._rateLimit;
   }
 
   public generateIdentityCredentials(): IdentityCredential {

package/bundle/_virtual/__node-resolve_empty.js

@@ -1,6 +0,0 @@
-import * as _nodeResolve_empty from './_node-resolve_empty.js';
-import { getAugmentedNamespace } from './_commonjsHelpers.js';
-
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty);
-
-export { require$$0 as default };

package/bundle/_virtual/_node-resolve_empty.js

@@ -1,3 +0,0 @@
-var _nodeResolve_empty = {};
-
-export { _nodeResolve_empty as default };

package/bundle/_virtual/bn.js

@@ -1,3 +0,0 @@
-var bn = {exports: {}};
-
-export { bn as __module };

package/bundle/_virtual/common.js

@@ -1,3 +0,0 @@
-var common = {};
-
-export { common as __exports };

package/bundle/_virtual/common2.js

@@ -1,3 +0,0 @@
-var common = {};
-
-export { common as __exports };

package/bundle/_virtual/hash.js

@@ -1,3 +0,0 @@
-var hash = {};
-
-export { hash as __exports };

package/bundle/_virtual/inherits_browser.js

@@ -1,3 +0,0 @@
-var inherits_browser = {exports: {}};
-
-export { inherits_browser as __module };

package/bundle/_virtual/ripemd.js

@@ -1,3 +0,0 @@
-var ripemd = {};
-
-export { ripemd as __exports };

package/bundle/_virtual/sha.js

@@ -1,3 +0,0 @@
-var sha = {};
-
-export { sha as __exports };

package/bundle/_virtual/sha3.js

@@ -1,3 +0,0 @@
-var sha3 = {exports: {}};
-
-export { sha3 as __module };

package/bundle/_virtual/utils3.js

@@ -1,3 +0,0 @@
-var utils = {};
-
-export { utils as __exports };

package/bundle/node_modules/@ethersproject/abi/lib.esm/_version.js

@@ -1,3 +0,0 @@
-const version = "abi/5.7.0";
-
-export { version };

package/bundle/node_modules/@ethersproject/abi/lib.esm/abi-coder.js

@@ -1,96 +0,0 @@
-import { arrayify } from '../../bytes/lib.esm/index.js';
-import { defineReadOnly } from '../../properties/lib.esm/index.js';
-import { Logger } from '../../logger/lib.esm/index.js';
-import { version } from './_version.js';
-import { Reader, Writer } from './coders/abstract-coder.js';
-import { AddressCoder } from './coders/address.js';
-import { ArrayCoder } from './coders/array.js';
-import { BooleanCoder } from './coders/boolean.js';
-import { BytesCoder } from './coders/bytes.js';
-import { FixedBytesCoder } from './coders/fixed-bytes.js';
-import { NullCoder } from './coders/null.js';
-import { NumberCoder } from './coders/number.js';
-import { StringCoder } from './coders/string.js';
-import { TupleCoder } from './coders/tuple.js';
-import { ParamType } from './fragments.js';
-
-const logger = new Logger(version);
-const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
-const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
-class AbiCoder {
-    constructor(coerceFunc) {
-        defineReadOnly(this, "coerceFunc", coerceFunc || null);
-    }
-    _getCoder(param) {
-        switch (param.baseType) {
-            case "address":
-                return new AddressCoder(param.name);
-            case "bool":
-                return new BooleanCoder(param.name);
-            case "string":
-                return new StringCoder(param.name);
-            case "bytes":
-                return new BytesCoder(param.name);
-            case "array":
-                return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);
-            case "tuple":
-                return new TupleCoder((param.components || []).map((component) => {
-                    return this._getCoder(component);
-                }), param.name);
-            case "":
-                return new NullCoder(param.name);
-        }
-        // u?int[0-9]*
-        let match = param.type.match(paramTypeNumber);
-        if (match) {
-            let size = parseInt(match[2] || "256");
-            if (size === 0 || size > 256 || (size % 8) !== 0) {
-                logger.throwArgumentError("invalid " + match[1] + " bit length", "param", param);
-            }
-            return new NumberCoder(size / 8, (match[1] === "int"), param.name);
-        }
-        // bytes[0-9]+
-        match = param.type.match(paramTypeBytes);
-        if (match) {
-            let size = parseInt(match[1]);
-            if (size === 0 || size > 32) {
-                logger.throwArgumentError("invalid bytes length", "param", param);
-            }
-            return new FixedBytesCoder(size, param.name);
-        }
-        return logger.throwArgumentError("invalid type", "type", param.type);
-    }
-    _getWordSize() { return 32; }
-    _getReader(data, allowLoose) {
-        return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);
-    }
-    _getWriter() {
-        return new Writer(this._getWordSize());
-    }
-    getDefaultValue(types) {
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = new TupleCoder(coders, "_");
-        return coder.defaultValue();
-    }
-    encode(types, values) {
-        if (types.length !== values.length) {
-            logger.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, {
-                count: { types: types.length, values: values.length },
-                value: { types: types, values: values }
-            });
-        }
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = (new TupleCoder(coders, "_"));
-        const writer = this._getWriter();
-        coder.encode(writer, values);
-        return writer.data;
-    }
-    decode(types, data, loose) {
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = new TupleCoder(coders, "_");
-        return coder.decode(this._getReader(arrayify(data), loose));
-    }
-}
-const defaultAbiCoder = new AbiCoder();
-
-export { AbiCoder, defaultAbiCoder };