@waku/rln/dist/contract/rln_base_contract.d.ts

RLN (Rate Limiting Nullifier) implementation for Waku

import { ethers } from "ethers";
import { IdentityCredential } from "../identity.js";
import { DecryptedCredentials } from "../keystore/types.js";
import { CustomQueryOptions, FetchMembersOptions, Member, MembershipInfo, RLNContractInitOptions } from "./types.js";
export declare class RLNBaseContract {
    contract: ethers.Contract;
    private deployBlock;
    private rateLimit;
    private minRateLimit?;
    private maxRateLimit?;
    protected _members: Map<number, Member>;
    private _membersFilter;
    private _membershipErasedFilter;
    private _membersExpiredFilter;
    /**
     * Private constructor for RLNBaseContract. Use static create() instead.
     */
    protected constructor(options: RLNContractInitOptions);
    /**
     * Static async factory to create and initialize RLNBaseContract
     */
    static create(options: RLNContractInitOptions): Promise<RLNBaseContract>;
    /**
     * Gets the current rate limit for this contract instance
     */
    getRateLimit(): number;
    /**
     * Gets the contract address
     */
    get address(): string;
    /**
     * Gets the contract provider
     */
    get provider(): ethers.providers.Provider;
    /**
     * Gets the minimum allowed rate limit (cached)
     */
    getMinRateLimit(): number;
    /**
     * Gets the maximum allowed rate limit (cached)
     */
    getMaxRateLimit(): number;
    /**
     * Gets the maximum total rate limit across all memberships
     * @returns Promise<number> The maximum total rate limit in messages per epoch
     */
    getMaxTotalRateLimit(): Promise<number>;
    /**
     * Gets the current total rate limit usage across all memberships
     * @returns Promise<number> The current total rate limit usage in messages per epoch
     */
    getCurrentTotalRateLimit(): Promise<number>;
    /**
     * Gets the remaining available total rate limit that can be allocated
     * @returns Promise<number> The remaining rate limit that can be allocated
     */
    getRemainingTotalRateLimit(): Promise<number>;
    /**
     * Updates the rate limit for future registrations
     * @param newRateLimit The new rate limit to use
     */
    setRateLimit(newRateLimit: number): void;
    get members(): Member[];
    fetchMembers(options?: FetchMembersOptions): Promise<void>;
    static queryFilter(contract: ethers.Contract, options: CustomQueryOptions): Promise<ethers.Event[]>;
    processEvents(events: ethers.Event[]): void;
    static splitToChunks(from: number, to: number, step: number): Array<[number, number]>;
    static takeN<T>(array: T[], size: number): Iterable<T[]>;
    static ignoreErrors<T>(promise: Promise<T>, defaultValue: T): Promise<T>;
    subscribeToMembers(): void;
    getMembershipInfo(idCommitmentBigInt: bigint): Promise<MembershipInfo | undefined>;
    extendMembership(idCommitmentBigInt: bigint): Promise<ethers.ContractTransaction>;
    eraseMembership(idCommitmentBigInt: bigint, eraseFromMembershipSet?: boolean): Promise<ethers.ContractTransaction>;
    registerMembership(idCommitmentBigInt: bigint, rateLimit?: number): Promise<ethers.ContractTransaction>;
    withdraw(token: string, walletAddress: string): Promise<void>;
    registerWithIdentity(identity: IdentityCredential): Promise<DecryptedCredentials | undefined>;
    registerWithPermitAndErase(identity: IdentityCredential, permit: {
        owner: string;
        deadline: number;
        v: number;
        r: string;
        s: string;
    }, idCommitmentsToErase: string[]): Promise<DecryptedCredentials | undefined>;
    /**
     * Validates that the rate limit is within the allowed range (sync)
     * @throws Error if the rate limit is outside the allowed range
     */
    private validateRateLimit;
    private get membersFilter();
    private get membershipErasedFilter();
    private get membersExpiredFilter();
    private getMemberIndex;
    getMembershipStatus(idCommitment: bigint): Promise<"expired" | "grace" | "active">;
    /**
     * Checks if a membership is expired for the given idCommitment
     * @param idCommitmentBigInt The idCommitment as bigint
     * @returns Promise<boolean> True if expired, false otherwise
     */
    isExpired(idCommitmentBigInt: bigint): Promise<boolean>;
    /**
     * Checks if a membership is in grace period for the given idCommitment
     * @param idCommitmentBigInt The idCommitment as bigint
     * @returns Promise<boolean> True if in grace period, false otherwise
     */
    isInGracePeriod(idCommitmentBigInt: bigint): Promise<boolean>;
    /**
     * Calculates the price for a given rate limit using the PriceCalculator contract
     * @param rateLimit The rate limit to calculate the price for
     * @param contractFactory Optional factory for creating the contract (for testing)
     */
    getPriceForRateLimit(rateLimit: number, contractFactory?: typeof import("ethers").Contract): Promise<{
        token: string | null;
        price: import("ethers").BigNumber | null;
    }>;
}