@gurge/sdk 0.3.120 → 0.3.142

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

@@ -1,34 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,37 +0,0 @@
-import { ethers } from 'ethers';
-import { ChainBalanceFetchingLock } from '../../../mutexes/chainBalanceRwLock';
-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: ChainBalanceFetchingLock;
-    constructor(chainId: number, contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, eventsFetchingMutex: ChainBalanceFetchingLock, 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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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;
-}

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

@@ -1,21 +0,0 @@
-import { AbstractSolanaEventService } from './AbstractSolanaEventService';
-import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
-export interface SolanaSnapshot<SnapshotPayloadType> {
-    readonly latestBlockNumber: number;
-    readonly payload: SnapshotPayloadType;
-}
-export declare abstract class AbstractSolanaSnapshotService<EventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractSolanaEventService<EventType> {
-    private savedLatestSlot;
-    protected constructor(solanaBlockchainEventEmitter: SolanaBlockchainEventEmitter, eventName: string);
-    init(): Promise<void>;
-    retrieveEventsFromLatestBlock(): Promise<void>;
-    private loadSnapshot;
-    protected saveSnapshot(): Promise<unknown>;
-    protected afterEventsAccepted(eventsCount: number): Promise<void>;
-    protected abstract getSnapshotPayload(): SnapshotPayloadType;
-    protected abstract populateSnapshot(snapshot: SolanaSnapshot<SnapshotPayloadType>): void;
-    protected abstract serializeSnapshot(snapshot: SolanaSnapshot<SnapshotPayloadType>): SerializedSnapshotType;
-    protected abstract deserializeSnapshot(serializedSnapshot: SerializedSnapshotType): SolanaSnapshot<SnapshotPayloadType>;
-    protected abstract fetchSnapshot(): Promise<SerializedSnapshotType>;
-    protected abstract persistSnapshot(serializedSnapshot: SerializedSnapshotType): Promise<unknown>;
-}

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

@@ -1,11 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { Idl } from '@coral-xyz/anchor';
-import { SolanaBlockchainEventEmitter } from './SolanaBlockchainEventEmitter';
-import { ChainBalanceFetchingLock } from '../../../mutexes/chainBalanceRwLock';
-import { ClientEventHelper } from '../helpers/ClientEventHelper';
-export declare class ClientSolanaBlockchainEventEmitter extends SolanaBlockchainEventEmitter {
-    clientEventHelper: ClientEventHelper;
-    constructor(chainId: number, connection: Connection, programId: PublicKey, initialSlot: number, eventsFetchingMutex: ChainBalanceFetchingLock, maxPageSize?: number, idl?: Idl);
-    protected clear(): void;
-    protected startUpdateListener(): void;
-}

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

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

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

@@ -1,42 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { Idl } from '@coral-xyz/anchor';
-import { ChainBalanceFetchingLock } from '../../../mutexes/chainBalanceRwLock';
-import { EventProcessorFunction } from '../../../types/events.types';
-import { BlockchainEvent } from '../../BlockchainEvent/BlockchainEvent';
-export declare abstract class SolanaBlockchainEventEmitter {
-    private readonly _chainId;
-    readonly connection: Connection;
-    readonly programId: PublicKey;
-    private _latestSlot;
-    private _initialSlot;
-    onEventsProcessed?: (acceptedEventCount: number) => void;
-    private eventProcessors;
-    private readonly maxPageSize?;
-    private _isReady;
-    protected isServer: boolean;
-    private inProgress;
-    private anchorParser?;
-    private anchorCoder?;
-    protected eventsFetchingMutex: ChainBalanceFetchingLock;
-    constructor(chainId: number, connection: Connection, programId: PublicKey, initialSlot: number, isServer: boolean, eventsFetchingMutex: ChainBalanceFetchingLock, maxPageSize?: number);
-    get chainId(): number;
-    get latestBlockNumber(): number;
-    get isReady(): boolean;
-    setIdl(idl: Idl): void;
-    syncFromAtMost(slot: number): void;
-    protected advanceLatestBlockNumber(slot: number): void;
-    intervalClear(): void;
-    init(): Promise<void>;
-    private requireReady;
-    addEventProcessorFunction(eventProcessorFunction: EventProcessorFunction): void;
-    getEventsInRange(fromSlot: number, toSlot: number): Promise<BlockchainEvent[]>;
-    getLastBlockNumberForEventRequest(): Promise<number>;
-    retrieveEvents(fromBlock: number, useForce?: boolean, initialLoading?: boolean): Promise<boolean>;
-    private getProgramEvents;
-    private parseTransactionForEvents;
-    private parseLogsForEvents;
-    private parseCpiForEvents;
-    protected processEvents(events: BlockchainEvent[], scannedToBlock?: number): Promise<void>;
-    protected abstract clear(): void;
-    protected abstract startUpdateListener(): void;
-}

package/common/src/data-structures/http/BasicHttpClient.d.ts

@@ -1,11 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { HttpClient } from '../../types/http.types';
-export declare class BasicHttpClient implements HttpClient {
-    private axiosInstance;
-    constructor();
-    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
-    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
-    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
-    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
-    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
-}

package/common/src/data-structures/http/HttpClient.d.ts

@@ -1,10 +0,0 @@
-import { HttpClient } from '../../types/http.types';
-declare const httpClient: {
-    setHttpClient: (client: HttpClient) => void;
-    get: <T = any>(url: string, config?: any) => Promise<T>;
-    post: <T = any>(url: string, data?: any, config?: any) => Promise<T>;
-    put: <T = any>(url: string, data?: any, config?: any) => Promise<T>;
-    patch: <T = any>(url: string, data?: any, config?: any) => Promise<T>;
-    delete: <T = any>(url: string, config?: any) => Promise<T>;
-};
-export { httpClient };

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

@@ -1,2 +0,0 @@
-export * from './HttpClient';
-export * from './BasicHttpClient';

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

@@ -1,22 +0,0 @@
-export * from './ValueCache';
-export * from './crypto-keys';
-export * from './Hinkal';
-export * from './private-balances';
-export * from './merkle-tree';
-export * from './provider-adapter/IProviderAdapter';
-export * from './event-service';
-export * from './utxo/Utxo';
-export * from './custom-token-registry/CustomTokenRegistry';
-export * from './token-price-fetcher';
-export * from './transactions-manager';
-export * from './MultiThreadedUtxoUtils/MultiThreadedUtxoUtils';
-export * from './cacheDevices';
-export * from './IndexedDB';
-export * from './TokenDBs';
-export * from './presale';
-export * from './snapshot';
-export * from './http';
-export * from './ApprovalDBs';
-export * from './BlockchainEvent/BlockchainEvent';
-export * from './AccountActions';
-export * from './WalletManager';

package/common/src/data-structures/merkle-tree/MerkleTree.d.ts

@@ -1,82 +0,0 @@
-export type MerkleTreeJson = {
-    tree: Record<string, string>;
-    reverseTree?: Record<string, string>;
-    count: string;
-    index: string;
-};
-/**
- * Merkle tree implementation that allows the user to insert in specific places in the tree
- *
- */
-export declare class MerkleTree<T> {
-    private hashFunction;
-    private levels;
-    private defaultNodeValue;
-    /**
-     * the map where the items are stored
-     */
-    private readonly tree;
-    /**
-     * amount of elements inserted inside the bottom row of the tree
-     */
-    private count;
-    /**
-     * the maximum index inserted into the tree
-     * used together with count to make sure that the merkle tree is complete.
-     * meaning that there aren't any missing elements between getStartIndex() and index
-     */
-    private index;
-    private reverseTree;
-    static createWithData<T>(tree: Map<bigint, T>, reverseTree: Map<T, bigint> | undefined, index: bigint, count: bigint, hashFunction: (a: T, b: T) => T, levels: bigint, defaultNodeValue: T): MerkleTree<T>;
-    /**
-     * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
-     * @param levels the amount of layers in the merkle tree
-     * @param defaultNodeValue the default value of an empty node in the merkle tree
-     */
-    static create<T>(hashFunction: (a: T, b: T) => T, defaultNodeValue: T, levels?: bigint): MerkleTree<T>;
-    private createReverseTree;
-    private constructor();
-    /**
-     * get starting nodeIndex from which inserts are allowed
-     */
-    getStartIndex(): bigint;
-    /**
-     * implementation of logarithm2 function from merkle contract
-     */
-    logarithm2(a: bigint): bigint;
-    bigIntMax(a: bigint, b: bigint): bigint;
-    private forceInsert;
-    /**
-     * insert value into the merkle tree
-     * @param value the value to insert
-     * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
-     * @throws will throw RangeError if nodeIndex is less than getStartIndex()
-     */
-    insert(value: T, nodeIndex: bigint): void;
-    remove(nodeIndex: bigint): void;
-    private completenessCheck;
-    /**
-     * get root hash of the merkle tree
-     * @returns the hash, if the merkle tree is empty, will return
-     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
-     */
-    getRootHash(): T | undefined;
-    getMerkleData(): Map<bigint, T>;
-    getValue(index: bigint): T | undefined;
-    getSiblingIndex(index: bigint): bigint;
-    /**
-     * get sibling hashes needed by main.circom
-     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
-     */
-    getSiblingHashesForVerification(item: T): bigint[] | T[];
-    /**
-     * get item's sibling hashes side
-     * @returns sibling's indexes
-     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
-     */
-    getSiblingSides(item: T): bigint[];
-    toJSON(): MerkleTreeJson;
-    toJSONLite(): MerkleTreeJson;
-    clone(): MerkleTree<T>;
-    getIndex(): bigint;
-}

package/common/src/data-structures/merkle-tree/MerkleTreeIncompleteError.d.ts

@@ -1,3 +0,0 @@
-export declare class MerkleTreeIncompleteError extends Error {
-    constructor();
-}

package/common/src/data-structures/merkle-tree/index.d.ts

@@ -1,2 +0,0 @@
-export * from './MerkleTree';
-export * from './MerkleTreeIncompleteError';

package/common/src/data-structures/presale/PresaleContractWrapper.d.ts

@@ -1,23 +0,0 @@
-import { ERC20Token } from '../../types/token.types';
-import { ethers } from 'ethers';
-export declare class PresaleContractWrapper {
-    contract: ethers.Contract;
-    eventsFrom: number;
-    constructor(signerOrProvider: ethers.Signer | ethers.Provider, chainId: number);
-    deposit(token: ERC20Token, amount: bigint, minHINK: bigint): Promise<ethers.ContractTransaction>;
-    withdraw(token: string, amount: bigint): Promise<ethers.ContractTransaction>;
-    moveToNextStage(overrides?: ethers.Overrides): Promise<ethers.ContractTransaction>;
-    estimateMoveToNextStageGas(): Promise<bigint>;
-    getTotalDeposit(): Promise<bigint>;
-    getDeposits(depositor: string, token: ERC20Token): Promise<bigint>;
-    getTotalHINK(depositor: string): Promise<bigint>;
-    getCurrentPresaleStageIndex(): Promise<number>;
-    getCurrentMaxDepositAmount(): Promise<bigint>;
-    currentPresaleStage(): Promise<{
-        amountToRaise: bigint;
-        priceMultiplier: bigint;
-    }>;
-    calculateHINK(amount: bigint): Promise<bigint>;
-    queryDeposits(): Promise<(ethers.EventLog | ethers.Log)[]>;
-    onEvent(eventName: string, handleEvent: ethers.Listener): void;
-}

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

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

package/common/src/data-structures/private-balances/BalanceChangedHandler.d.ts

@@ -1,9 +0,0 @@
-import { PrivateBalanceUpdateEventType } from '../../types';
-type BalanceChangeListener = (detail?: PrivateBalanceUpdateEventType) => void;
-export declare class BalanceChangedHandler {
-    private readonly listeners;
-    subscribe(listener: BalanceChangeListener): () => void;
-    dispatch(detail: PrivateBalanceUpdateEventType): void;
-}
-export declare const balanceChangedHandler: BalanceChangedHandler;
-export {};

package/common/src/data-structures/private-balances/HinkalPrivateBalanceController.d.ts

@@ -1,21 +0,0 @@
-import { PrivateBalancesState } from '../../types/balances.types';
-import { IHinkal } from '../Hinkal/IHinkal';
-export declare class HinkalPrivateBalanceController {
-    private privateBalancesState;
-    private readonly privateBalancesListeners;
-    private readonly hinkal;
-    private readonly unsubscribeBalanceChange;
-    constructor(hinkal: IHinkal);
-    getSnapshot(): PrivateBalancesState;
-    onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void;
-    dispose(): void;
-    private applyRefreshFromBalanceChangeEvent;
-    private dispatch;
-    private getAddressAndChain;
-    private hasCache;
-    private getBalancesWithUsdValues;
-    private handleCached;
-    private handleFresh;
-    private getSupportedChainsToUpdate;
-    private refreshInternal;
-}

package/common/src/data-structures/private-balances/index.d.ts

@@ -1,3 +0,0 @@
-export * from './BalanceChangedHandler';
-export * from './HinkalPrivateBalanceController';
-export * from './privateBalancesReducer';

package/common/src/data-structures/private-balances/privateBalancesReducer.d.ts

@@ -1,2 +0,0 @@
-import { PrivateBalancesAction, PrivateBalancesState } from '../../types/balances.types';
-export declare const privateBalancesReducer: (currentState: PrivateBalancesState, action: PrivateBalancesAction) => PrivateBalancesState;

package/common/src/data-structures/provider-adapter/IProviderAdapter.d.ts

@@ -1,40 +0,0 @@
-import { ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
-import { ethers } from 'ethers';
-import { Call } from '../../types/eip5792.types';
-import { Transaction } from '@solana/web3.js';
-export interface ChainEventListener {
-    onAccountChanged(): void;
-    onChainChanged(chainId?: number): void;
-}
-export interface IProviderAdapter<ConnectorType = unknown> {
-    initConnector(connector: ConnectorType): void;
-    initSigner?(signer: ethers.Signer): void;
-    init(chainId?: number): Promise<void>;
-    initConfig?(config?: any): Promise<void> | void;
-    connectToConnector(connector: ConnectorType): Promise<number>;
-    disconnectFromConnector(): Promise<void>;
-    connectAndPatchProvider(connector: ConnectorType): Promise<number>;
-    getChainId(): number | undefined;
-    waitForTransaction(chainId: number, transactionHash: string, confirmations: number): Promise<boolean>;
-    signMessage(message: string | Uint8Array): Promise<string>;
-    getAddress(): Promise<string>;
-    setChainEventListener(chainEventListener: ChainEventListener): void;
-    release(): void;
-    getContract(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
-    getContractWithSigner(chainId: number, contract: ContractType, contractAddress?: string): ethers.Contract;
-    getContractWithFetcher(chainId: number, contract: ContractType, contractAddress?: string): ethers.Contract;
-    sendTransaction(tx: ethers.TransactionRequest): Promise<ethers.TransactionResponse>;
-    switchNetwork(network: EthereumNetwork): Promise<unknown>;
-    onAccountChanged(): Promise<unknown>;
-    onChainChanged(chainId?: number): Promise<unknown>;
-    isPermitterAvailable(): boolean;
-    getGasPrice(chainId: number): Promise<bigint>;
-    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
-    sendBatchCallsTransaction?(chainId: number, calls: Call[]): Promise<ethers.TransactionResponse>;
-    supportsBatchCall?(chainId: number): Promise<boolean>;
-    signTransactionWithoutBroadcast?(tx: Transaction): Promise<{
-        signature: string;
-        transactionMessageB64: string;
-    }>;
-    isSolanaLedger?(): boolean;
-}

package/common/src/data-structures/snapshot/SnapshotFetcherService.d.ts

@@ -1,14 +0,0 @@
-import { ISnapshotsResponse } from '../../API/fetchCommitmentsCache';
-export declare class SnapshotFetcherService {
-    private chainId;
-    private contractAddress;
-    private snapshotsPromise;
-    private lastFetchedAt;
-    private readonly cacheDurationMs;
-    constructor(chainId: number, contractAddress: string, cacheDurationMs?: number);
-    private fetchSnapshots;
-    private ensureSnapshots;
-    getAll(forceRefresh?: boolean): Promise<ISnapshotsResponse>;
-    getCommitments(forceRefresh?: boolean): Promise<import('../../API/fetchCommitmentsCache').ICommitmentsTreeSnapshot>;
-    getNullifiers(forceRefresh?: boolean): Promise<import('../../API/fetchCommitmentsCache').INullifiersSnapshot>;
-}