@hinkal/common 0.2.11 → 0.2.12

package/data-structures/event-service/AbstractCommitmentsSnapshotService.d.mts

@@ -1,30 +0,0 @@
-import { ethers } from 'ethers';
-import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
-import { CommitmentEvent, EncryptedOutputWithSign } from '../../types';
-import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
-export type CommitmentsSnapshotPayload = {
-    readonly merkleTree: MerkleTree<bigint>;
-    readonly encryptedOutputs: EncryptedOutputWithSign[];
-};
-export type CommitmentsSerializedSnapshot = {
-    latestBlockNumber?: number;
-    reserveBlockNumber?: number;
-    merkleTree?: MerkleTreeJson;
-    encryptedOutputs?: EncryptedOutputWithSign<string>[];
-};
-export declare abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<CommitmentEvent<bigint>, CommitmentEvent, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
-    private _merkleTree;
-    private _encryptedOutputs;
-    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>[];
-    };
-    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs }, }: Snapshot<CommitmentsSnapshotPayload>): void;
-    protected mapEvent(event: CommitmentEvent): CommitmentEvent<bigint>;
-    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number): boolean;
-}

package/data-structures/event-service/AbstractEventService.d.mts

@@ -1,31 +0,0 @@
-import { ethers } from 'ethers';
-export type NewEventListener<E> = (event?: E) => unknown;
-export interface EventConfig {
-    name: string;
-    args: string[];
-}
-export declare abstract class AbstractEventService<EventType, SerializedEventType = unknown> {
-    protected readonly contract: ethers.Contract;
-    protected readonly eventConfig: EventConfig;
-    protected _latestBlockNumber: number;
-    private readonly maxPageSize?;
-    private isReady;
-    private _onNewEvent?;
-    protected isServer: boolean;
-    protected intervalId?: any;
-    protected inProgress: boolean;
-    protected constructor(contract: ethers.Contract, eventConfig: EventConfig, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
-    get latestBlockNumber(): number;
-    set onNewEvent(value: NewEventListener<EventType>);
-    intervalClear(): void;
-    init(): Promise<void>;
-    protected requireReady(): void;
-    protected emitNewEvent(event?: EventType): void;
-    private getLastBlockNumberForEventRequest;
-    protected retrieveEvents(fromBlockNumber: number, useForce?: boolean): Promise<boolean>;
-    private processEventsPage;
-    protected handleEvent: (...args: unknown[]) => Promise<void>;
-    protected abstract acceptEvent(event: EventType, blockNumber: number): boolean | Promise<boolean>;
-    protected abstract mapEvent(event: SerializedEventType): EventType;
-    protected abstract afterEventsAccepted(): Promise<unknown>;
-}

package/data-structures/event-service/AbstractNullifierSnapshotService.d.mts

@@ -1,22 +0,0 @@
-import { BigNumber, ethers } from 'ethers';
-import { NullifierEvent } from '../../types/commitments.types';
-import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
-export type NullifierSnapshotPayload = {
-    readonly nullifiers: Set<string>;
-};
-export type NullifierSerializedSnapshot = {
-    latestBlockNumber?: number;
-    reserveBlockNumber?: number;
-    nullifiers?: string[];
-};
-export declare abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<NullifierEvent<string>, NullifierEvent<BigNumber>, NullifierSnapshotPayload, NullifierSerializedSnapshot> {
-    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
-    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: NullifierEvent<BigNumber>): NullifierEvent<string>;
-    protected getSnapshotPayload(): NullifierSnapshotPayload;
-    protected populateSnapshot({ payload: { nullifiers } }: Snapshot<NullifierSnapshotPayload>): void;
-}

package/data-structures/event-service/AbstractSnapshotService.d.mts

@@ -1,23 +0,0 @@
-import { ethers } from 'ethers';
-import { AbstractEventService, EventConfig } from './AbstractEventService';
-export interface Snapshot<SnapshotPayloadType> {
-    readonly latestBlockNumber: number;
-    readonly reserveBlockNumber: number;
-    readonly payload: SnapshotPayloadType;
-}
-export declare abstract class AbstractSnapshotService<EventType, SerializedEventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractEventService<EventType, SerializedEventType> {
-    protected reserveBlockNumber: number;
-    protected constructor(contract: ethers.Contract, eventConfig: EventConfig, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
-    init(): Promise<void>;
-    retrieveEventsFromLatestBlock(): Promise<void>;
-    restoreSnapshotState(): Promise<void>;
-    private loadSnapshot;
-    protected saveSnapshot(): Promise<unknown>;
-    protected afterEventsAccepted(): Promise<unknown>;
-    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/data-structures/event-service/index.d.mts

@@ -1,5 +0,0 @@
-export * from './AbstractAccessTokenSnapshotService';
-export * from './AbstractCommitmentsSnapshotService';
-export * from './AbstractNullifierSnapshotService';
-export * from './AbstractSnapshotService';
-export * from './AbstractEventService';

package/data-structures/index.d.mts

@@ -1,13 +0,0 @@
-export * from './ValueCache';
-export * from './crypto-keys';
-export * from './Hinkal';
-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 './volatile-helper';
-export * from './MultiThreadedUtxoUtils/MultiThreadedUtxoUtils';
-export * from './cacheDevices';

package/data-structures/merkle-tree/MerkleTree.d.mts

@@ -1,78 +0,0 @@
-export type MerkleTreeJson = {
-    tree: 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;
-    static createWithData<T>(tree: Map<bigint, T>, 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, levels: bigint, defaultNodeValue: T): MerkleTree<T>;
-    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()
-     * @return true - if added, false - if already exists
-     * @throws will throw RangeError if nodeIndex is less than getStartIndex()
-     */
-    insert(value: T, nodeIndex: bigint): boolean;
-    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>;
-    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;
-    clone(): MerkleTree<T>;
-    getIndex(): bigint;
-}

package/data-structures/merkle-tree/MerkleTreeIncompleteError.d.mts

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

package/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.d.mts

@@ -1,3 +0,0 @@
-import { UserKeys } from '../crypto-keys/keys';
-import { MerkleTree } from './MerkleTree';
-export declare const getPatchedAccessTokenMerkleTree: (merkleTreeAccessToken: MerkleTree<bigint>, userKeys: UserKeys, hasAccessToken: boolean) => MerkleTree<bigint>;

package/data-structures/merkle-tree/index.d.mts

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

package/data-structures/provider-adapter/IProviderAdapter.d.mts

@@ -1,35 +0,0 @@
-import { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
-import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
-import { Contract, ethers, Signer } from 'ethers';
-export interface ChainEventListener {
-    onAccountChanged(): void;
-    onChainChanged(chainId?: number): void;
-}
-export interface IProviderAdapter<ConnectorType = unknown> {
-    chainId: number | undefined;
-    initConnector(connector: ConnectorType): void;
-    initSigner?(signer: 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>;
-    waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
-    signMessage(message: string | Uint8Array): Promise<string>;
-    getAddress(): Promise<string>;
-    getSelectedNetwork(): EthereumNetwork | undefined;
-    setChainEventListener(chainEventListener: ChainEventListener): void;
-    release(): void;
-    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
-    getContract(contractType: ContractType, contractAddress?: string, chainId?: number): ethers.Contract;
-    getContractWithSigner(contract: ContractType, contractAddress?: string): Contract;
-    getContractWithFetcher(contract: ContractType, contractAddress?: string): Contract;
-    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): Contract;
-    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
-    switchNetwork(network: EthereumNetwork): Promise<unknown>;
-    onAccountChanged(): Promise<unknown>;
-    onChainChanged(chainId?: number): Promise<unknown>;
-    isPermitterAvailable(): boolean;
-    getGasPrice(): Promise<bigint>;
-    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
-}

package/data-structures/snapshot/ClientAccessTokenSnapshotService.d.mts

@@ -1,7 +0,0 @@
-import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot } from '../event-service';
-import { Contract } from 'ethers';
-export declare class ClientAccessTokenSnapshotService extends AbstractAccessTokenSnapshotService {
-    constructor(contract: Contract, maxPageSize?: number);
-    protected fetchSnapshot(): Promise<AccessTokenSerializedSnapshot>;
-    protected persistSnapshot(_serializedSnapshot: AccessTokenSerializedSnapshot): Promise<unknown>;
-}

package/data-structures/snapshot/ClientCommitmentsSnapshotService.d.mts

@@ -1,7 +0,0 @@
-import { AbstractCommitmentsSnapshotService, CommitmentsSerializedSnapshot } from '../event-service';
-import { Contract } from 'ethers';
-export declare class ClientCommitmentsSnapshotService extends AbstractCommitmentsSnapshotService {
-    constructor(contract: Contract, maxPageSize?: number);
-    protected fetchSnapshot(): Promise<CommitmentsSerializedSnapshot>;
-    protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
-}

package/data-structures/snapshot/ClientNullifierSnapshotService.d.mts

@@ -1,7 +0,0 @@
-import { AbstractNullifierSnapshotService, NullifierSerializedSnapshot } from '../event-service';
-import { Contract } from 'ethers';
-export declare class ClientNullifierSnapshotService extends AbstractNullifierSnapshotService {
-    constructor(contract: Contract, maxPageSize?: number);
-    protected fetchSnapshot(): Promise<NullifierSerializedSnapshot>;
-    protected persistSnapshot(_serializedSnapshot: NullifierSerializedSnapshot): Promise<unknown>;
-}

package/data-structures/token-price-fetcher/TokenChecker.d.mts

@@ -1,20 +0,0 @@
-import { ERC20Token } from '../../types/token.types';
-export declare class TokenChecker {
-    static isCurveLPToken: (token: ERC20Token, curveTokens: string[]) => boolean;
-    static isCurveStakeToken: (token: ERC20Token) => boolean;
-    static isConvexToken: (token: ERC20Token) => boolean;
-    static isBeefyLpToken: (token: ERC20Token) => boolean;
-    static isBeefyStakeToken: (token: ERC20Token) => boolean;
-    static isLidoToken: (token: ERC20Token) => boolean;
-    static isCurveOrConvex: (token: ERC20Token, curveTokens: string[]) => boolean;
-    static isBeefyToken: (token: ERC20Token) => boolean;
-    static isStakeToken: (token: ERC20Token) => boolean;
-    static isPendleYtToken: (token: ERC20Token) => boolean;
-    static isPendleLPToken: (token: ERC20Token) => boolean;
-    static isPendleSyToken: (token: ERC20Token) => boolean;
-    static isPendleNativeToken: (token: ERC20Token) => boolean;
-    static isPendleToken: (token: ERC20Token) => boolean;
-    static isAaveToken: (token: ERC20Token) => boolean | undefined;
-    static isKinzaToken: (token: ERC20Token) => boolean;
-    static isProtocolToken: (token: ERC20Token, curveTokens: string[]) => boolean | undefined;
-}

package/data-structures/token-price-fetcher/index.d.mts

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

package/data-structures/transactions-manager/TransactionsManager.d.mts

@@ -1,27 +0,0 @@
-import { Contract } from 'ethers';
-import { DecodedTx, HashInfoByChain, RawTx } from '../../types';
-import { TransactionField } from './history/history.types';
-import { UserKeys } from '../crypto-keys';
-export declare class TransactionsManager {
-    readonly circuitSize: number;
-    hinkalContract: Contract;
-    init(hinkalContract: Contract): void;
-    requireInit(): void;
-    private filterOwnTransactions;
-    private saveTxsInStorage;
-    private loadTxsFromStorage;
-    getAllTransactions: (chainId: number, userKeys: UserKeys, week?: number, startWeek?: number) => Promise<RawTx[]>;
-    getHinkalHistoryBase: (chainId: number, userKeys: UserKeys, week?: number, includeOthersDeposits?: boolean, startWeek?: number) => Promise<DecodedTx[]>;
-    getHinkalHistory: (chainId: number, userKeys: UserKeys) => Promise<TransactionField[]>;
-    private sortInBatches;
-    private generateTransactionsProof;
-    private userVerifyTransactions;
-    private verifyTransactionsInBatches;
-    processAndSendTransactionsForVerification: (chainId: number, userKeys: UserKeys, ethereumAddress: string, latestCertifiedHash?: string, startWeek?: number) => Promise<{
-        trade: number;
-        transactions: number;
-        lockedDeposit: number;
-        verification: boolean;
-    }>;
-    multiProcessAndSendTransactionsForVerification: (userKeys: UserKeys, ethereumAddress: string, lastCertifiedHashes?: HashInfoByChain) => Promise<boolean>;
-}

package/data-structures/transactions-manager/history/getBeefyData.d.mts

@@ -1,3 +0,0 @@
-import { BeefyResult, PastTransaction } from './history.types';
-import { OnChainUtxo } from '../../../types';
-export declare const getBeefyData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => BeefyResult;

package/data-structures/transactions-manager/history/getConvexData.d.mts

@@ -1,6 +0,0 @@
-import { ConvexAction, OnChainUtxo } from '../../../types';
-import { ConvexStakeUnstake, PastTransaction, TransactionType } from './history.types';
-export declare const getConvexData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => ConvexStakeUnstake | {
-    type: TransactionType;
-    convexAction: ConvexAction;
-};

package/data-structures/transactions-manager/history/getCurveData.d.mts

@@ -1,6 +0,0 @@
-import { CurveAction, OnChainUtxo } from '../../../types';
-import { CurveDepositWithdrawResult, CurveStakeUnstake, PastTransaction, TransactionType } from './history.types';
-export declare const getCurveData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => CurveDepositWithdrawResult | CurveStakeUnstake | {
-    type: TransactionType;
-    curveAction: CurveAction;
-};

package/data-structures/transactions-manager/history/getDepositData.d.mts

@@ -1,2 +0,0 @@
-import { DepositResult, PastTransaction, WithdrawResult } from './history.types';
-export declare const getDepositData: (input: PastTransaction, chainId: number) => DepositResult | WithdrawResult;

package/data-structures/transactions-manager/history/getLidoData.d.mts

@@ -1,10 +0,0 @@
-import { ERC20Token, OnChainUtxo } from '../../../types';
-import { PastTransaction, TransactionType } from './history.types';
-export declare const getLidoData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => {
-    lidoToken: {
-        token: ERC20Token | undefined;
-        balance: bigint;
-    };
-    type: TransactionType;
-    lidoAction: any;
-};

package/data-structures/transactions-manager/history/getPendleData.d.mts

@@ -1,3 +0,0 @@
-import { PastTransaction, PendleResult } from './history.types';
-import { OnChainUtxo } from '../../../types';
-export declare const getPendleData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => PendleResult;

package/data-structures/transactions-manager/history/getSwapData.d.mts

@@ -1,3 +0,0 @@
-import { OnChainUtxo } from '../../../types';
-import { PastTransaction, SwapResult } from './history.types';
-export declare const getSwapData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => SwapResult;

package/data-structures/transactions-manager/history/getTxDetails.d.mts

@@ -1,3 +0,0 @@
-import { OnChainUtxo } from '../../../types';
-import { PastTransaction, TransactionDetails } from './history.types';
-export declare const getTxDetails: (chainId: number, input: PastTransaction, utxosArray?: OnChainUtxo[]) => Promise<TransactionDetails>;

package/data-structures/transactions-manager/history/getVolatileData.d.mts

@@ -1,32 +0,0 @@
-import { PastTransaction, TransactionType } from './history.types';
-import { OnChainUtxo } from '../../../types';
-export declare const getVolatileData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => Promise<{
-    tokenWithBalance: {
-        token: import('../../../types/token.types').ERC20Token | {
-            erc20TokenAddress: string;
-        };
-        balance: bigint;
-    };
-    type: TransactionType;
-    tokenIn?: undefined;
-    tokenOut?: undefined;
-    protocol?: undefined;
-} | {
-    tokenIn: {
-        token: import('../../../types/token.types').ERC20Token | undefined;
-        balance: bigint;
-    };
-    tokenOut: {
-        token: import('../../../types/token.types').ERC20Token | undefined;
-        balance: bigint | undefined;
-    };
-    type: TransactionType;
-    protocol: bigint;
-    tokenWithBalance?: undefined;
-} | {
-    type: TransactionType;
-    tokenWithBalance?: undefined;
-    tokenIn?: undefined;
-    tokenOut?: undefined;
-    protocol?: undefined;
-}>;

package/data-structures/transactions-manager/history/history.types.d.mts

@@ -1,95 +0,0 @@
-import { BeefyAction, ConvexAction, CurveAction, HookDataType, LidoAction, PendleAction, TokenBalance } from '../../../types';
-import { BigNumber } from 'ethers';
-export type PastTransaction = {
-    erc20TokenAddresses: string[];
-    amountChanges: BigNumber[];
-    externalActionId: BigNumber;
-    externalActionMetadata: string;
-    hookData: HookDataType;
-};
-export declare enum TransactionType {
-    DEPOSIT = 0,
-    WITHDRAW = 1,
-    SWAP = 2,
-    BEEFY = 3,
-    CURVE = 4,
-    CONVEX = 5,
-    LIDO = 6,
-    PENDLE = 7,
-    VOLATILE = 8,
-    UNKNOWN = 9
-}
-export declare const externalActionToTransactionType: (input: PastTransaction) => TransactionType.DEPOSIT | TransactionType.WITHDRAW | TransactionType.SWAP | TransactionType.BEEFY | TransactionType.CURVE | TransactionType.CONVEX | TransactionType.LIDO | TransactionType.PENDLE | TransactionType.UNKNOWN;
-export interface TransactionDetails {
-    type: TransactionType;
-}
-export type HistoryTokenBalance = TokenBalance | {
-    token: {
-        erc20TokenAddress: string;
-    };
-    balance: bigint;
-};
-export interface DepositResult extends TransactionDetails {
-    tokenWithBalance: HistoryTokenBalance;
-    type: TransactionType.DEPOSIT;
-}
-export interface WithdrawResult extends TransactionDetails {
-    tokenWithBalance: HistoryTokenBalance;
-    type: TransactionType.WITHDRAW;
-}
-export interface SwapResult extends TransactionDetails {
-    tokenIn: HistoryTokenBalance;
-    tokenOut: HistoryTokenBalance;
-    type: TransactionType.SWAP;
-    protocol: bigint;
-}
-export interface BeefyResult extends TransactionDetails {
-    erc20Token: HistoryTokenBalance;
-    mooToken: HistoryTokenBalance;
-    type: TransactionType.BEEFY;
-    beefyAction: BeefyAction;
-}
-export interface CurveDepositWithdrawResult extends TransactionDetails {
-    inTokens: HistoryTokenBalance[];
-    poolToken: HistoryTokenBalance;
-    type: TransactionType.CURVE;
-    curveAction: CurveAction;
-}
-export interface CurveStakeUnstake extends TransactionDetails {
-    poolToken: HistoryTokenBalance;
-    type: TransactionType.CURVE;
-    curveAction: CurveAction;
-}
-export interface ConvexStakeUnstake extends TransactionDetails {
-    poolToken: HistoryTokenBalance;
-    type: TransactionType.CONVEX;
-    convexAction: ConvexAction;
-}
-export interface LidoResult extends TransactionDetails {
-    lidoToken: HistoryTokenBalance;
-    type: TransactionType.LIDO;
-    lidoAction: LidoAction;
-}
-export interface PendleResult extends TransactionDetails {
-    pendleTokens: HistoryTokenBalance[];
-    nonPendleTokens: HistoryTokenBalance[];
-    syToken?: HistoryTokenBalance;
-    type: TransactionType.PENDLE;
-    pendleAction: PendleAction | undefined;
-}
-export interface VolatileResult extends TransactionDetails {
-    token: HistoryTokenBalance;
-    type: TransactionType.VOLATILE;
-}
-export interface UnknownTransaction extends TransactionDetails {
-    type: TransactionType.UNKNOWN;
-}
-export type TransactionField = {
-    blockNumber: number;
-    timeStamp: number;
-    gas: number;
-    gasPrice: number;
-    hash: string;
-    status: 'SUCCESS' | 'FAILURE';
-    details: TransactionDetails;
-};

package/data-structures/transactions-manager/history/history.utils.d.mts

@@ -1,8 +0,0 @@
-import { PastTransaction } from './history.types';
-export declare const txHistoryToBigInt: (input: PastTransaction) => {
-    amountChanges: bigint[];
-    externalActionId: bigint;
-    erc20TokenAddresses: string[];
-    externalActionMetadata: string;
-    hookData: import('../../../index.ts').HookDataType;
-};

package/data-structures/transactions-manager/index.d.mts

@@ -1,2 +0,0 @@
-export * from './TransactionsManager';
-export * from './history/history.types';

package/data-structures/utxo/Utxo.d.mts

@@ -1,63 +0,0 @@
-export type IUtxoConstructor = {
-    amount: bigint;
-    erc20TokenAddress: string;
-    timeStamp?: string;
-    shieldedPrivateKey?: string;
-    randomization?: bigint;
-    stealthAddress?: string;
-    encryptionKey?: string;
-    tokenId?: number;
-    isStake?: boolean;
-    isStakeOrUnstakeInput?: boolean;
-    isUnstakeOutput?: boolean;
-    commitment?: string;
-    nullifier?: string;
-};
-/**
- * UTXO class for transactions
- */
-export declare class Utxo {
-    amount: bigint;
-    erc20TokenAddress: string;
-    timeStamp: string;
-    tokenId: number;
-    shieldedPrivateKey?: string;
-    randomization: bigint;
-    stealthAddress?: string;
-    encryptionKey?: string;
-    commitment?: string;
-    nullifier?: string;
-    isStake: boolean;
-    isStakeOrUnstakeInput: boolean;
-    isUnstakeOutput: boolean;
-    /**
-     * creates new UTXO instance
-     * @param amount UTXO amount
-     * @param erc20TokenAddress contract address of ERC-20/ERC-721 token
-     * @param timeStamp timestamp
-     * @param tokenId tokenId
-     * @param randomization randomization parameter
-     * @param stealthAddress  stealth address as a parameter(e.g. in case of transfers we will not know private key and randomization of payee
-     * @param encryptionKey  encryption public key
-     * @param shieldedPrivateKey private key for nullification
-     * @param commitment [optional] commitment value if already computed
-     * @param nullifier [optional] nullifier value if already computed
-     */
-    constructor({ amount, erc20TokenAddress, timeStamp, tokenId, shieldedPrivateKey, randomization, stealthAddress, encryptionKey, commitment, nullifier, isStake, isStakeOrUnstakeInput, isUnstakeOutput, }: IUtxoConstructor);
-    static createFrom(utxoToCreateFrom: Utxo, patch: Partial<IUtxoConstructor>): Utxo;
-    getConstructableParams(): IUtxoConstructor;
-    /**
-     * @returns commitment hash of the UTXO instance
-     */
-    getCommitment(): string;
-    /**
-     * @returns nullifier hash of the UTXO instance
-     */
-    getNullifier(): string;
-    /**
-     * @returns stealth address from randomization and private shieldedPrivateKey
-     */
-    getStealthAddress(): string;
-    getEncryptionKey(): string;
-    static findCorrectRandomization(initialRandomization: bigint, privateKey?: string): bigint;
-}