@hinkal/common 0.2.10 → 0.2.11

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

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

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

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

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

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

package/data-structures/index.d.mts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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