@gurge/sdk 0.3.5 → 0.3.8

package/common/src/data-structures/TokenDBs/PublicTokensDB.d.ts

@@ -0,0 +1,9 @@
+import { ERC20Token } from '../../types/token.types';
+import { IPublicTokensDB } from './IPublicTokensDB';
+export declare class PublicTokensDB implements IPublicTokensDB {
+    private useAlternativeDB;
+    getPublicTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    getFetchedTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    fetchAndUpdatePublicTokens(walletAddress: string, chainId: number): Promise<void>;
+}
+export declare const publicTokensDB: PublicTokensDB;

package/common/src/data-structures/TokenDBs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './PrivateTokensDB';
+export * from './PublicTokensDB';
+export * from './token-visibility-db';
+export * from './ArcPublicTokensDB';

package/common/src/data-structures/TokenDBs/token-visibility-db.d.ts

@@ -0,0 +1,17 @@
+import { ERC20Token } from '../../types/token.types';
+declare class TokenVisibilityStorage {
+    private readonly STORAGE_KEY;
+    private readonly UNHIDDEN_SPAM_KEY;
+    getHiddenTokens(chainId: number): Promise<ERC20Token[]>;
+    private getHiddenTokenAddresses;
+    filterOutHiddenTokens(chainId: number, tokens: ERC20Token[]): Promise<ERC20Token[]>;
+    hideToken(token: ERC20Token): Promise<void>;
+    showToken(token: ERC20Token): Promise<void>;
+    private storeUnhiddenSpamToken;
+    private deleteUnhiddenSpamToken;
+    getUnhiddenSpamTokens(chainId: number): Promise<ERC20Token[]>;
+    private hideUnnecessarySpamTokens;
+    hideSpamsAndFetchHiddenTokensAddresses(chainId: number, tokens: ERC20Token[]): Promise<string[]>;
+}
+export declare const tokenVisibilityStorage: TokenVisibilityStorage;
+export {};

package/common/src/data-structures/ValueCache/ValueCache.d.ts

@@ -0,0 +1,10 @@
+export declare class ValueCache<T> {
+    constructor(timeoutInMs: number);
+    protected timeoutInMs: number;
+    values: {
+        [key: string]: T;
+    };
+    private setTimer;
+    private onTimeout;
+    clear(): void;
+}

package/common/src/data-structures/ValueCache/index.d.ts

@@ -0,0 +1 @@
+export * from './ValueCache';

package/common/src/data-structures/WalletManager/WalletManager.d.ts

@@ -0,0 +1,51 @@
+export declare class WalletManager {
+    private mainWallet;
+    private tronMainWallet;
+    private mnemonicPhrase;
+    private readonly ethDerivationBasePath;
+    private readonly tronDerivationBasePath;
+    generateMnemonic(wordCount?: 12 | 24): string[];
+    isValidMnemonic(mnemonic: string): boolean;
+    isValidWord(word: string): boolean;
+    createEvmWallet(index: number): {
+        address: string;
+        privateKey: string;
+    };
+    createTronWallet(index: number): {
+        address: string;
+        privateKey: string;
+    };
+    createSolanaAccount(accountIndex?: number): Promise<{
+        publicKey: string;
+        secretKey: string;
+    }>;
+    createChildWallet(index: number): Promise<{
+        ethereum: {
+            address: string;
+            privateKey: string;
+        };
+        tron: {
+            address: string;
+            privateKey: string;
+        };
+        solana: {
+            publicKey: string;
+            secretKey: string;
+        };
+    }>;
+    private deriveEd25519Path;
+    createMainWallet(mnemonic: string): Promise<{
+        ethereum: {
+            address: string;
+            privateKey: string;
+        };
+        tron: {
+            address: string;
+            privateKey: string;
+        };
+        solana: {
+            publicKey: string;
+            secretKey: string;
+        };
+    }>;
+}

package/common/src/data-structures/WalletManager/index.d.ts

@@ -0,0 +1 @@
+export * from './WalletManager';

package/common/src/data-structures/cacheDevices/AttachableMemoryCacheDevice.d.ts

@@ -0,0 +1,8 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class AttachableMemoryCacheDevice<T> extends BaseCacheDevice<T> {
+    private isAttached;
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    serialize(): Record<string, string>;
+    attach<ArgsType extends unknown[]>(func: (...args: ArgsType) => T): (...args: ArgsType) => T;
+}

package/common/src/data-structures/cacheDevices/BaseCacheDevice.d.ts

@@ -0,0 +1,11 @@
+import { ICacheDevice } from '../../types/ICacheDevice';
+export declare abstract class BaseCacheDevice<T = string> implements ICacheDevice<T> {
+    protected inMemoryCache: Map<string, T>;
+    constructor(serialized?: Record<string, string>);
+    protected getInMemory(key: string): T | undefined;
+    protected setInMemory(key: string, value: T): void;
+    abstract get(key: string): T | undefined;
+    abstract set(key: string, value: T): void;
+    abstract serialize(): Record<string, string>;
+    mergeWithSerialized(serialized: Record<string, string>): void;
+}

package/common/src/data-structures/cacheDevices/FileCacheDevice.d.ts

@@ -0,0 +1,10 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class FileCacheDevice extends BaseCacheDevice {
+    private filePath;
+    private useFileCache;
+    constructor(useFileCache: boolean | undefined, filePath: string);
+    private readFileFromDevice;
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    serialize(): Record<string, string>;
+}

package/common/src/data-structures/cacheDevices/LocalStorageCacheDevice.d.ts

@@ -0,0 +1,8 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class LocalStorageCacheDevice extends BaseCacheDevice {
+    private localDataStorage;
+    constructor(disableCaching?: boolean, serializedCache?: Record<string, string>);
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    serialize(): Record<string, string>;
+}

package/common/src/data-structures/cacheDevices/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FileCacheDevice';
+export * from './LocalStorageCacheDevice';

package/common/src/data-structures/crypto-keys/decodeUTXO.d.ts

@@ -0,0 +1,28 @@
+import { IUtxoConstructor, Utxo } from '../utxo/Utxo';
+export declare const encodeSolanaOnChainUtxo: (onChainData: number[][]) => string;
+export declare const isSolanaOnChainUtxo: (encodedOutput: string) => boolean;
+export declare const decodeSolanaUtxo: (encodedOutput: string) => {
+    amount: bigint;
+    erc20TokenAddress: string;
+    mintAddress: string;
+    randomization: bigint;
+    stealthAddress: string;
+    H0: bigint;
+    H1: bigint;
+    timeStamp: string;
+    isNewStyle: boolean;
+};
+export declare const decodeEvmUtxo: (encryptedOutput: string) => {
+    amount: bigint;
+    erc20TokenAddress: string;
+    randomization: bigint;
+    isNewStyle: boolean;
+    stealthAddress: string;
+    H0: bigint;
+    H1: bigint;
+    timeStamp: string;
+    tokenId: number;
+};
+export declare const checkUtxoSignature: (encryptedOutput: string, privateKey: string, chainId: number) => boolean;
+export declare const decodeUtxoConstructorArgs: (encryptedOutput: string, privateKey: string, chainId: number) => IUtxoConstructor;
+export declare const decodeUtxo: (encryptedOutput: string, privateKey: string, chainId: number) => Utxo;

package/common/src/data-structures/crypto-keys/encryptDecryptUtxo.d.ts

@@ -0,0 +1,18 @@
+import { IUtxoConstructor, Utxo } from '../utxo/Utxo';
+import { UserKeys } from './keys';
+/**
+ * encrypt data for the UTXO
+ * @param amount UTXO amount
+ * @param blinding UTXO blinding
+ * @param publicKey sender's encryption public key
+ * @returns returns encrypted data {Uint8Array}
+ */
+export declare const encryptUtxo: (utxo: Utxo) => Uint8Array;
+export declare const decryptUtxoConstructorArgs: (encryptedData: Uint8Array, userKeys: UserKeys) => IUtxoConstructor;
+/**
+ * decrypt UTXO data from events
+ * @param encryptedData encrypted UTXO data {Uint8Array}
+ * @param publicKey/privateKey sender's encryption keys
+ * @returns decrypted UTXO data Object {amount, blinding}
+ */
+export declare const decryptUtxo: (encryptedData: Uint8Array, userKeys: UserKeys) => Utxo;

package/common/src/data-structures/crypto-keys/index.d.ts

@@ -0,0 +1,4 @@
+export * from './decodeUTXO';
+export * from './encryptDecryptUtxo';
+export * from './keys';
+export * from './keyUtils';

package/common/src/data-structures/crypto-keys/keyUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const isCircomNegative: (n: bigint) => boolean;
+export declare const getCircomSign: (n: bigint) => 0n | 1n;

package/common/src/data-structures/crypto-keys/keys.d.ts

@@ -0,0 +1,131 @@
+import { JubPoint } from '../../crypto/babyJub';
+import { AttachableMemoryCacheDevice } from '../cacheDevices/AttachableMemoryCacheDevice';
+export declare const stealthPairCacheDevice: AttachableMemoryCacheDevice<{
+    H0: [bigint, bigint];
+    H1: [bigint, bigint];
+}>;
+export declare const stealthPairOldCacheDevice: AttachableMemoryCacheDevice<{
+    H0: [bigint, bigint];
+    H1: [bigint, bigint];
+}>;
+export declare const stealthAddressCacheDevice: AttachableMemoryCacheDevice<string>;
+export interface EncryptionKeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+export declare const EncryptionKeyPairDefaultValue: EncryptionKeyPair;
+export declare class UserKeys {
+    private signature;
+    private nullifyingKey;
+    private readonly PREFIX_FOR_SPENDING_PAIR;
+    private readonly PREFIX_FOR_NULLIFYING_PAIR;
+    constructor(_signature?: string, _nullifyingKey?: string);
+    getSignature(): string;
+    setSignature(_signature: string): void;
+    private requireSignature;
+    private requireKeyMaterial;
+    verifyTronMessage(signingMessage: string, signerAddress: string): boolean;
+    /**
+     * get shielded private key from message signature used to login to the application,
+     * this private key is used to generate encryption keypairs as well as public key
+     * @retuns 0x-prefixed shielded private key
+     */
+    getShieldedPrivateKey: () => string;
+    /**
+     * generate shielded public key from private key
+     * @param privateKey the key used to generate the shielded public key, this should be the signature
+     * that the user provided
+     * @retuns shielded public key in hexstring with 0x prefixed
+     */
+    getShieldedPublicKey: () => string;
+    /**
+     * derive the EdDSA-Poseidon BabyJubJub public key for the spending private key. This must match
+     * the key that `signEddsa` (circomlib's signPoseidon) signs with, i.e. the scalar is derived from
+     * blake512(prv) + clamping, not from privSpendingKey directly.
+     */
+    getSpendingKeyPair: () => {
+        privSpendingKey: string;
+        pubSpendingBJJPoint: JubPoint;
+    };
+    /**
+     * EdDSA-Poseidon sign a message (a circom field element as bigint) using the shielded private key
+     * as the EdDSA secret. Returns { R8, S } with R8 as a JubPoint and S as a bigint scalar.
+     */
+    signEddsa: (message: bigint) => {
+        R8: JubPoint;
+        S: bigint;
+    };
+    /**
+     * Currently used for creating shielded private keys for deposit UTXOs, which are encrypted and sent to enclave for private send
+     * @param nonce Used to deterministically generate new shielded private key
+     * @returns new shielded private key in hexstring with 0x prefixed
+     */
+    getShieldedPrivateKeyFromNonce: (nonce: bigint) => string;
+    getClaimableSignatureFromNonce: (nonce: bigint) => string;
+    /**
+     * deterministically derive an EVM address from the shielded private key
+     */
+    getDerivedEthereumAddress: () => string;
+    /**
+     * deterministically derive a Solana public key from the shielded private key
+     */
+    getDerivedSolanaPublicKey: () => string;
+    /**
+     * deterministically derive the user's NEAR Intents account id from the shielded private key.
+     * The account id is the NEAR implicit account (lowercase hex of the ed25519 public key) of the
+     * same keypair returned by getDerivedSolanaPublicKey. Used as a private cross-chain refund
+     * destination so refunds never expose the user's public main wallet.
+     */
+    getNearIntentsAccountId: () => string;
+    /**
+     * deterministically derive the NEAR Intents signing key from the shielded private key,
+     * formatted as a near-api-js KeyPair string ("ed25519:<base58 secret>"). Pairs with
+     * getNearIntentsAccountId() and is used client-side to authorize claiming cross-chain
+     * bridge refunds back out of the user's Intents account.
+     */
+    getNearIntentsKeyPairString: () => string;
+    /**
+     * generate access token, this accessKey is what should be sent to the server for signing
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getSignerPrivateKeyFromNonce: (walletNonce: bigint) => string;
+    getSignerSolanaPrivateKeyFromNonce: (walletNonce: bigint) => string;
+    verifyMessage(signingMessage: string): string;
+    verifySolanaMessage(signingMessage: string, signerPublicKey: string): boolean;
+    static getRandomizedStealthPairOld: (s: bigint, privateKey: string) => {
+        H0: [bigint, bigint];
+        H1: [bigint, bigint];
+    };
+    static getRandomizedStealthPair: (s: bigint, privateKey: string) => {
+        H0: [bigint, bigint];
+        H1: [bigint, bigint];
+    };
+    static getStealthAddressCompressedPoints: (s: bigint, privateKey: string) => {
+        h0: bigint;
+        h1: bigint;
+    };
+    static checkSignature: (s: bigint, stealthAddressH0: bigint, stealthAddressH1: bigint, privateKey: string) => boolean;
+    static getStealthAddress: (s: bigint, privateKey: string) => string;
+    static getH1FromH0: (H0: JubPoint, privateKey: string) => JubPoint;
+    static verifyStealthPair: (H0: JubPoint, H1: JubPoint, privateKey: string, onlyYCheck?: boolean) => boolean;
+    static getStealthAddressNewStyle: (H0: JubPoint, nullifyingPrivateKey: string, spendingPublicKey?: bigint[]) => string;
+    static findCorrectRandomization(initialRandomization: bigint, privateKey?: string): bigint;
+    static getH0FromRandomization: (randomization: bigint) => JubPoint;
+    static findH0(randomization: bigint, privateKey: string | undefined): JubPoint | undefined;
+    /**
+     * generate private and public keypair
+     * @param seed seed to use to deterministically generate key, must be in DataHexString format
+     * and must correspond to 32 bytes
+     */
+    static getEncryptionKeyPair: (privateKey: string) => EncryptionKeyPair;
+    /**
+     * generate access token, this accessKey is what should be sent to the server for signing
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getAccessKey: () => string;
+    /**
+     * generate backend token, which is used for access control on backend
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getBackendToken: () => string;
+}

package/common/src/data-structures/custom-token-registry/CustomTokenRegistry.d.ts

@@ -0,0 +1,12 @@
+import { ERC20Token } from '../../types';
+declare class CustomTokenRegistry {
+    tokenRegistry: ERC20Token[];
+    constructor();
+    setTokensFromCache(newTokenRegistries: ERC20Token[]): void;
+    getCustomTokens(chainId: number): ERC20Token[];
+    tokenExists(registry: ERC20Token[], tokenToCheck: ERC20Token): ERC20Token | undefined;
+    addCustomToken(token: ERC20Token): void;
+    removeCustomToken(tokenToRemove: ERC20Token): void;
+}
+export declare const customTokenRegistry: CustomTokenRegistry;
+export {};

package/common/src/data-structures/event-service/evm/AbstractCommitmentsSnapshotService.d.ts

@@ -0,0 +1,34 @@
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithCommitment, EncryptedOutputWithSign } from '../../../types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type CommitmentsSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly encryptedOutputs: EncryptedOutputWithSign[];
+    readonly encryptedOutputsByCommitment: Map<bigint, string>;
+};
+export type CommitmentsSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    encryptedOutputs?: EncryptedOutputWithSign<string>[];
+    encryptedOutputsByCommitment?: EncryptedOutputWithCommitment[];
+};
+export declare abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<CommitmentEvent<bigint>, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
+    private _merkleTree;
+    private _encryptedOutputs;
+    private _encryptedOutputsByCommitment;
+    get merkleTree(): MerkleTree<bigint>;
+    get encryptedOutputs(): EncryptedOutputWithSign<boolean>[];
+    protected serializeSnapshot(snapshot: Snapshot<CommitmentsSnapshotPayload>): CommitmentsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: CommitmentsSerializedSnapshot): Snapshot<CommitmentsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        merkleTree: MerkleTree<bigint>;
+        encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+        encryptedOutputsByCommitment: Map<bigint, string>;
+    };
+    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs, encryptedOutputsByCommitment }, }: Snapshot<CommitmentsSnapshotPayload>): void;
+    protected mapEvent(event: BlockchainEvent): CommitmentEvent<bigint>;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number, _txHash?: string, isBlocked?: boolean): boolean;
+}

package/common/src/data-structures/event-service/evm/AbstractEventService.d.ts

@@ -0,0 +1,14 @@
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+export declare abstract class AbstractEventService<EventType> {
+    protected blockchainEventEmitter: BlockchainEventEmitter;
+    protected readonly eventName: string;
+    protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string);
+    get latestBlockNumber(): number;
+    get chainId(): number;
+    intervalClear(): void;
+    private processEventsPage;
+    protected abstract acceptEvent(event: EventType, blockNumber: number, txHash?: string, isBlocked?: boolean): boolean | Promise<boolean>;
+    protected abstract mapEvent(event: BlockchainEvent): EventType;
+    protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
+}

package/common/src/data-structures/event-service/evm/AbstractNullifierSnapshotService.d.ts

@@ -0,0 +1,22 @@
+import { NullifierEvent } from '../../../types/commitments.types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type NullifierSnapshotPayload = {
+    readonly nullifiers: Set<string>;
+};
+export type NullifierSerializedSnapshot = {
+    latestBlockNumber?: number;
+    nullifiers?: string[];
+};
+export declare abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<NullifierEvent<string>, NullifierSnapshotPayload, NullifierSerializedSnapshot> {
+    constructor(hinkalEventEmitter: BlockchainEventEmitter);
+    private _nullifiers;
+    get nullifiers(): Set<string>;
+    protected serializeSnapshot(snapshot: Snapshot<NullifierSnapshotPayload>): NullifierSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: NullifierSerializedSnapshot): Snapshot<NullifierSnapshotPayload>;
+    protected acceptEvent(event: NullifierEvent<string>, _blockNumber: number): boolean;
+    protected mapEvent(event: BlockchainEvent): NullifierEvent<string>;
+    protected getSnapshotPayload(): NullifierSnapshotPayload;
+    protected populateSnapshot({ payload: { nullifiers } }: Snapshot<NullifierSnapshotPayload>): void;
+}

package/common/src/data-structures/event-service/evm/AbstractSnapshotService.d.ts

@@ -0,0 +1,22 @@
+import { AbstractEventService } from './AbstractEventService';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+export interface Snapshot<SnapshotPayloadType> {
+    readonly latestBlockNumber: number;
+    readonly payload: SnapshotPayloadType;
+}
+export declare abstract class AbstractSnapshotService<EventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractEventService<EventType> {
+    private savedLatestBlockNumber;
+    protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string);
+    init(): Promise<void>;
+    retrieveEventsFromLatestBlock(): Promise<void>;
+    get isReady(): boolean;
+    private loadSnapshot;
+    protected saveSnapshot(): Promise<unknown>;
+    protected afterEventsAccepted(eventsCount: number): Promise<void>;
+    protected abstract getSnapshotPayload(): SnapshotPayloadType;
+    protected abstract populateSnapshot(snapshot: Snapshot<SnapshotPayloadType>): void;
+    protected abstract serializeSnapshot(snapshot: Snapshot<SnapshotPayloadType>): SerializedSnapshotType;
+    protected abstract deserializeSnapshot(serializedSnapshot: SerializedSnapshotType): Snapshot<SnapshotPayloadType>;
+    protected abstract fetchSnapshot(): Promise<SerializedSnapshotType>;
+    protected abstract persistSnapshot(serializedSnapshot: SerializedSnapshotType): Promise<unknown>;
+}

package/common/src/data-structures/event-service/evm/BlockchainEventEmitter.d.ts

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers';
+import { Mutex } from 'async-mutex';
+import { EventProcessorFunction } from '../../../types/events.types';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export declare abstract class BlockchainEventEmitter {
+    private readonly RETRY_MIN_PAGE_SIZE;
+    private readonly MAX_RETRIES;
+    private readonly _chainId;
+    readonly contract: ethers.Contract;
+    readonly depositOnChainUtxosContract?: ethers.Contract;
+    private _latestBlockNumber;
+    private _initialBlockNumber;
+    onEventsProcessed?: (acceptedEventCount: number) => void;
+    private eventProcessors;
+    private readonly maxPageSize?;
+    private _isReady;
+    protected isServer: boolean;
+    private inProgress;
+    protected eventsFetchingMutex: Mutex;
+    constructor(chainId: number, contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, eventsFetchingMutex: Mutex, maxPageSize?: number, depositOnChainUtxosContract?: ethers.Contract);
+    get latestBlockNumber(): number;
+    get chainId(): number;
+    get isReady(): boolean;
+    syncFromAtMost(blockNumber: number): void;
+    protected advanceLatestBlockNumber(blockNumber: number): void;
+    intervalClear(): void;
+    init(): Promise<void>;
+    private requireReady;
+    private getEventsForSingleContract;
+    addEventProcessorFunction(eventProcessorFunction: EventProcessorFunction): void;
+    getEventsInRange(fromBlockNumber: number, toBlockNumber: number): Promise<BlockchainEvent[]>;
+    getLastBlockNumberForEventRequest(): Promise<number>;
+    retrieveEvents(fromBlockNumber: number, useForce?: boolean): Promise<boolean>;
+    protected processEvents(events: BlockchainEvent[], scannedToBlock?: number): Promise<void>;
+    protected abstract clear(): void;
+    protected abstract startUpdateListener(): void;
+}

package/common/src/data-structures/event-service/evm/ClientBlockchainEventEmitter.d.ts

@@ -0,0 +1,11 @@
+import { ethers } from 'ethers';
+import { EventCategory } from '../../../types/events.types';
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+import { Mutex } from 'async-mutex';
+import { ClientEventHelper } from '../helpers/ClientEventHelper';
+export declare class ClientBlockchainEventEmitter extends BlockchainEventEmitter {
+    clientEventHelper: ClientEventHelper;
+    constructor(eventCategory: EventCategory, chainId: number, contract: ethers.Contract, initialBlockNumber: number, eventsFetchingMutex: Mutex, maxPageSize?: number, depositOnChainUtxosContract?: ethers.Contract);
+    protected clear(): void;
+    protected startUpdateListener(): void;
+}

package/common/src/data-structures/event-service/evm/PollingBlockchainEventEmitter.d.ts

@@ -0,0 +1,6 @@
+import { BlockchainEventEmitter } from './BlockchainEventEmitter';
+export declare class PollingBlockchainEventEmitter extends BlockchainEventEmitter {
+    private pollingEventHelper;
+    protected clear(): void;
+    protected startUpdateListener(): void;
+}

package/common/src/data-structures/event-service/helpers/ClientEventHelper.d.ts

@@ -0,0 +1,10 @@
+import { EventCategory } from '../../../types/events.types';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export declare class ClientEventHelper {
+    chainId: number;
+    eventCategory: EventCategory;
+    private pollIntervalId;
+    constructor(chainId: number, eventCategory: EventCategory);
+    clear(): void;
+    startUpdateListener(processEvents: (events: BlockchainEvent[]) => Promise<void>, fromBlockNumber: number, onProcessed: (latestBlockNumber: number) => void): void;
+}

package/common/src/data-structures/event-service/helpers/PollingEventHelper.d.ts

@@ -0,0 +1,7 @@
+export declare class PollingEventHelper {
+    private intervalId;
+    private readonly pollIntervalMs;
+    constructor(isServer: boolean);
+    clear(): void;
+    startUpdateListener(retrieveEvents: () => Promise<void> | void): void;
+}

package/common/src/data-structures/event-service/index.d.ts

@@ -0,0 +1,14 @@
+export * from './evm/AbstractCommitmentsSnapshotService';
+export * from './evm/AbstractNullifierSnapshotService';
+export * from './evm/AbstractSnapshotService';
+export * from './evm/AbstractEventService';
+export * from './evm/BlockchainEventEmitter';
+export * from './evm/PollingBlockchainEventEmitter';
+export * from './evm/ClientBlockchainEventEmitter';
+export * from './solana/SolanaBlockchainEventEmitter';
+export * from './solana/ClientSolanaBlockchainEventEmitter';
+export * from './solana/PollingSolanaBlockchainEventEmitter';
+export * from './solana/AbstractSolanaEventService';
+export * from './solana/AbstractSolanaSnapshotService';
+export * from './solana/AbstractSolanaNullifierSnapshotService';
+export * from './solana/AbstractSolanaCommitmentsSnapshotService';

package/common/src/data-structures/event-service/solana/AbstractSolanaCommitmentsSnapshotService.d.ts

@@ -0,0 +1,34 @@
+import { MerkleTree, MerkleTreeJson } from '../../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithCommitment, EncryptedOutputWithSign } from '../../../types';
+import { AbstractSolanaSnapshotService, SolanaSnapshot } from './AbstractSolanaSnapshotService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type SolanaCommitmentsSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly encryptedOutputs: EncryptedOutputWithSign[];
+    readonly encryptedOutputsByCommitment: Map<bigint, string>;
+};
+export type SolanaCommitmentsSerializedSnapshot = {
+    latestBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    encryptedOutputs?: EncryptedOutputWithSign<string>[];
+    encryptedOutputsByCommitment?: EncryptedOutputWithCommitment[];
+};
+export declare abstract class AbstractSolanaCommitmentsSnapshotService extends AbstractSolanaSnapshotService<CommitmentEvent<bigint>, SolanaCommitmentsSnapshotPayload, SolanaCommitmentsSerializedSnapshot> {
+    constructor(solanaEventEmitter: SolanaBlockchainEventEmitter);
+    private _merkleTree;
+    private _encryptedOutputs;
+    private _encryptedOutputsByCommitment;
+    get merkleTree(): MerkleTree<bigint>;
+    get encryptedOutputs(): EncryptedOutputWithSign<boolean>[];
+    protected serializeSnapshot(snapshot: SolanaSnapshot<SolanaCommitmentsSnapshotPayload>): SolanaCommitmentsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: SolanaCommitmentsSerializedSnapshot): SolanaSnapshot<SolanaCommitmentsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        merkleTree: MerkleTree<bigint>;
+        encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+        encryptedOutputsByCommitment: Map<bigint, string>;
+    };
+    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs, encryptedOutputsByCommitment }, }: SolanaSnapshot<SolanaCommitmentsSnapshotPayload>): void;
+    protected mapEvent(event: BlockchainEvent): Promise<CommitmentEvent<bigint>>;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _slot: number, _signature?: string, isBlocked?: boolean): boolean;
+}

package/common/src/data-structures/event-service/solana/AbstractSolanaEventService.d.ts

@@ -0,0 +1,17 @@
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+type PromiseOrValue<T> = T | Promise<T>;
+export declare abstract class AbstractSolanaEventService<EventType> {
+    protected solanaBlockchainEventEmitter: SolanaBlockchainEventEmitter;
+    protected readonly eventName: string;
+    protected constructor(solanaBlockchainEventEmitter: SolanaBlockchainEventEmitter, eventName: string);
+    get latestBlockNumber(): number;
+    get isReady(): boolean;
+    get chainId(): number;
+    intervalClear(): void;
+    private processEventsPage;
+    protected abstract acceptEvent(event: EventType, slot: number, signature?: string, isBlocked?: boolean): boolean | Promise<boolean>;
+    protected abstract mapEvent(event: BlockchainEvent): PromiseOrValue<EventType>;
+    protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
+}
+export {};

package/common/src/data-structures/event-service/solana/AbstractSolanaNullifierSnapshotService.d.ts

@@ -0,0 +1,22 @@
+import { NullifierEvent } from '../../../types/commitments.types';
+import { AbstractSolanaSnapshotService, SolanaSnapshot } from './AbstractSolanaSnapshotService';
+import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
+import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
+export type SolanaNullifierSnapshotPayload = {
+    readonly nullifiers: Set<string>;
+};
+export type SolanaNullifierSerializedSnapshot = {
+    latestBlockNumber?: number;
+    nullifiers?: string[];
+};
+export declare abstract class AbstractSolanaNullifierSnapshotService extends AbstractSolanaSnapshotService<NullifierEvent<string>, SolanaNullifierSnapshotPayload, SolanaNullifierSerializedSnapshot> {
+    constructor(solanaEventEmitter: SolanaBlockchainEventEmitter);
+    private _nullifiers;
+    get nullifiers(): Set<string>;
+    protected serializeSnapshot(snapshot: SolanaSnapshot<SolanaNullifierSnapshotPayload>): SolanaNullifierSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: SolanaNullifierSerializedSnapshot): SolanaSnapshot<SolanaNullifierSnapshotPayload>;
+    protected acceptEvent(event: NullifierEvent<string>, _slot: number): boolean;
+    protected mapEvent(event: BlockchainEvent): NullifierEvent<string>;
+    protected getSnapshotPayload(): SolanaNullifierSnapshotPayload;
+    protected populateSnapshot({ payload: { nullifiers } }: SolanaSnapshot<SolanaNullifierSnapshotPayload>): void;
+}