@hinkal/common 0.2.10 → 0.2.11

package/functions/web3/runContractFunction.d.mts

@@ -0,0 +1,15 @@
+import { BigNumber, ethers } from 'ethers';
+interface IRunTransaction {
+    contractFunction: ethers.ContractFunction;
+    args: unknown[];
+    gasLimit?: number;
+    gasPrice?: BigNumber;
+    confirmations?: number;
+    waitTime?: number;
+    nonce?: number;
+}
+interface IRunContractFunction extends IRunTransaction {
+    provider: ethers.providers.Provider;
+}
+export declare const runContractFunction: ({ provider, contractFunction, args, gasLimit, nonce, confirmations, }: IRunContractFunction) => Promise<ethers.ContractReceipt>;
+export {};

package/functions/web3/uniswapAPI.d.mts

@@ -0,0 +1,16 @@
+import { Contract } from 'ethers';
+import { ERC20Token } from '../../types';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+interface PoolAndFee {
+    poolAddress: string;
+    fee: number;
+    token1Balance: bigint;
+}
+export declare const searchPoolAndFee: (token1Contract: Contract, factory: Contract, token0Address: string, token1Address: string) => Promise<PoolAndFee>;
+export declare const getUniswapPriceHelper: (hinkal: IHinkal, chainId: number, token0: ERC20Token, token1: ERC20Token, fee: number, inSwapAmount: bigint) => Promise<bigint>;
+export declare const getUniswapFee: (hinkal: IHinkal, chainId: number, token0: ERC20Token, token1: ERC20Token) => Promise<number>;
+export declare const getUniswapPrice: (hinkal: IHinkal, chainId: number, inSwapAmount: string, inSwapToken: ERC20Token, outSwapToken: ERC20Token) => Promise<{
+    tokenPrice: bigint;
+    poolFee: string;
+}>;
+export {};

package/index.d.mts

@@ -0,0 +1,8 @@
+export * from './API';
+export * from './constants';
+export * from './crypto';
+export * from './data-structures';
+export * from './error-handling';
+export * from './externalABIs';
+export * from './functions';
+export * from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hinkal/common",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "homepage": "hinkal.pro",
   "author": {
     "name": "Hinkal Protocol"
@@ -13,24 +13,54 @@
   ],
   "exports": {
     ".": {
-      "import": "./index.mjs",
-      "require": "./index.cjs"
+      "import": {
+        "types": "./index.d.mts",
+        "default": "./index.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.cjs"
+      }
     },
     "./providers/EthersProviderAdapter": {
-      "import": "./providers/EthersProviderAdapter.mjs",
-      "require": "./providers/EthersProviderAdapter.cjs"
+      "import": {
+        "types": "./providers/EthersProviderAdapter.d.mts",
+        "default": "./providers/EthersProviderAdapter.mjs"
+      },
+      "require": {
+        "types": "./providers/EthersProviderAdapter.d.ts",
+        "default": "./providers/EthersProviderAdapter.cjs"
+      }
     },
     "./providers/WagmiProviderAdapter": {
-      "import": "./providers/WagmiProviderAdapter.mjs",
-      "require": "./providers/WagmiProviderAdapter.cjs"
+      "import": {
+        "types": "./providers/WagmiProviderAdapter.d.mts",
+        "default": "./providers/WagmiProviderAdapter.mjs"
+      },
+      "require": {
+        "types:": "./providers/WagmiProviderAdapter.d.ts",
+        "default": "./providers/WagmiProviderAdapter.cjs"
+      }
     },
     "./providers/prepareEthersHinkal": {
-      "import": "./providers/prepareEthersHinkal.mjs",
-      "require": "./providers/prepareEthersHinkal.cjs"
+      "import": {
+        "types": "./providers/prepareEthersHinkal.d.mts",
+        "default": "./providers/prepareEthersHinkal.mjs"
+      },
+      "require": {
+        "types": "./providers/prepareEthersHinkal.d.ts",
+        "default": "./providers/prepareEthersHinkal.cjs"
+      }
     },
     "./providers/prepareWagmiHinkal": {
-      "import": "./providers/prepareWagmiHinkal.mjs",
-      "require": "./providers/prepareWagmiHinkal.cjs"
+      "import": {
+        "types": "./providers/prepareWagmiHinkal.d.mts",
+        "default": "./providers/prepareWagmiHinkal.mjs"
+      },
+      "require": {
+        "types": "./providers/prepareWagmiHinkal.d.ts",
+        "default": "./providers/prepareWagmiHinkal.cjs"
+      }
     }
   },
   "types": "./index.d.ts",

package/providers/EthersProviderAdapter.d.mts

@@ -0,0 +1,39 @@
+import { IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { ethers, Signer } from 'ethers';
+export declare class EthersProviderAdapter implements IProviderAdapter<Signer> {
+    signer: Signer | undefined;
+    chainId: number | undefined;
+    private originalProvider;
+    private fetchProvider;
+    initConnector(): void;
+    initSigner(signer: Signer): void;
+    requireSigner(): void;
+    init(chainId?: number): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    connectToConnector(): Promise<number>;
+    waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    getSelectedNetwork: () => EthereumNetwork | undefined;
+    switchNetwork(): Promise<void>;
+    private createFetchProvider;
+    getAddress(): Promise<string>;
+    setChainEventListener(): void;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    release(): void;
+    private parseChainIdParam;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contractType: ContractType, contractAddress?: undefined, chainId?: number): ethers.Contract;
+    getContractWithSigner(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    sendTransaction(tx: ethers.providers.TransactionRequest): Promise<ethers.providers.TransactionResponse>;
+    connectAndPatchProvider(): Promise<number>;
+    isPermitterAvailable(): boolean;
+    getGasPrice(): Promise<bigint>;
+}
+export declare const ethersProvierAdapter: EthersProviderAdapter;
+declare const _default: <T = unknown>() => IProviderAdapter<T>;
+export default _default;

package/providers/WagmiProviderAdapter.d.mts

@@ -0,0 +1,46 @@
+import { ChainEventListener, IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { ethers } from 'ethers';
+import { type Connector } from 'wagmi';
+export declare class WagmiProviderAdapter implements IProviderAdapter<Connector> {
+    private connector;
+    chainId: number | undefined;
+    private originalProvider;
+    private fetchProvider;
+    private signer;
+    private chainEventListener?;
+    private config?;
+    private unsubscribeFns;
+    initConnector(connector: Connector): void;
+    requireConnector(): void;
+    initConfig(config: any): void;
+    init(chainId?: number): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    connectToConnector(connector: Connector): Promise<number>;
+    waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    getSelectedNetwork: () => EthereumNetwork | undefined;
+    switchNetwork(network: EthereumNetwork): Promise<import("viem").Chain>;
+    private createFetchProvider;
+    getAddress(): Promise<string>;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    release(): void;
+    private removeListeners;
+    private parseChainIdParam;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contractType: ContractType, contractAddress?: undefined, chainId?: number): ethers.Contract;
+    getContractWithSigner(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    sendTransaction(tx: ethers.providers.TransactionRequest): Promise<ethers.providers.TransactionResponse>;
+    connectAndPatchProvider(connector: Connector): Promise<number>;
+    isPermitterAvailable(): boolean;
+    getGasPrice(): Promise<bigint>;
+    walletClientToSigner(walletClient: any, chainId: number): Promise<ethers.providers.JsonRpcSigner>;
+}
+export declare const wagmiProviderAdapter: WagmiProviderAdapter;
+declare const _default: <T = unknown>() => IProviderAdapter<T>;
+export default _default;

package/providers/exportProviers.d.mts

@@ -0,0 +1,3 @@
+import { IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+export declare const exportWagmiProvider: <T = unknown>() => Promise<IProviderAdapter<T>>;
+export declare const exportEthersProvider: () => Promise<IProviderAdapter<unknown>>;

package/providers/prepareEthersHinkal.d.mts

@@ -0,0 +1,4 @@
+import { type Signer } from 'ethers';
+import { Hinkal } from '../data-structures';
+import { type HinkalConfig } from '../types/hinkal.types';
+export declare const prepareEthersHinkal: (signer: Signer, hinkalConfig?: HinkalConfig) => Promise<Hinkal<unknown>>;

package/providers/prepareWagmiHinkal.d.mts

@@ -0,0 +1,3 @@
+import { Hinkal } from '../data-structures';
+import { type Config, type Connector } from 'wagmi';
+export declare const prepareWagmiHinkal: (connector: Connector, config: Config) => Promise<Hinkal<unknown>>;

package/types/API.types.d.mts

@@ -0,0 +1,23 @@
+import { RafflePrizeType } from './rewards.types';
+export interface ThirdPartyLeaderBoardItem {
+    nickname: string;
+    points: number;
+}
+export interface PointInfo {
+    lpPoints: number;
+    referralPoints: number;
+    certificationPoints: number;
+    tradePoints: number;
+    ambassadorPoints: number;
+    bonusPoints: number;
+}
+export interface LeaderBoardItem {
+    nickname: string;
+    points: number;
+    boost: number;
+    rafflePrizes?: RafflePrizeType[];
+    breakdown: PointInfo;
+}
+export interface LeaderboardEntry extends LeaderBoardItem {
+    position: number;
+}

package/types/ICacheDevice.d.mts

@@ -0,0 +1,4 @@
+export interface ICacheDevice {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+}

package/types/IMultiThreadedUtxoUtils.d.mts

@@ -0,0 +1,8 @@
+import { type Utxo } from '../data-structures/utxo/Utxo';
+import { type UserKeys } from '../data-structures/crypto-keys/keys';
+import { EncryptedOutputWithSign, OutputsWithSignAndLast } from './commitments.types';
+export interface IMultiThreadedUtxoUtils {
+    batchProcess(encryptedOutputs: EncryptedOutputWithSign[], lastOutput: string, userKeys: UserKeys): Promise<OutputsWithSignAndLast>;
+    buildBatchProcess(encryptedOutputs: EncryptedOutputWithSign[], userKeys: UserKeys): Promise<Utxo[]>;
+    batchFilterUtxosWithNullifier(allUtxos: Utxo[], nullifiers: Set<string>): Promise<Utxo[]>;
+}

package/types/admin.types.d.mts

@@ -0,0 +1,22 @@
+export declare enum AdminActionType {
+    Internal = "Internal",
+    External = "External"
+}
+export declare enum AdminDetailedActionType {
+    Deposit = "Deposit",
+    WithdrawWithRelayer = "Withdraw With Relayer",
+    WithdrawWithoutRelayer = "Withdraw Without Relayer",
+    MintAccessToken = "Mint Access Token",
+    Aave = "Aave",
+    Odos = "Odos",
+    Uniswap = "Uniswap",
+    OneInch = "1Inch",
+    Curve = "Curve",
+    Convex = "Convex",
+    Transact = "Transact",
+    Beefy = "Beefy",
+    Volatile = "Volatile",
+    Lido = "Lido",
+    Pendle = "Pendle",
+    HinkalStake = "HinkalStake"
+}

package/types/axelar.types.d.mts

@@ -0,0 +1,14 @@
+export interface AxelarMigrationInfo {
+    destinationChain: string;
+    destinationAddress: string;
+    messageFee: bigint;
+}
+export interface AxelarCapsule {
+    chains: AxelarMigrationInfo[];
+    totalMessageFees: bigint;
+}
+export interface AxelarNetworkSelection {
+    chainId: number;
+    gasFeeInWei?: bigint;
+    isSelected: boolean;
+}

package/types/beefy.types.d.mts

@@ -0,0 +1,11 @@
+import { BeefyAction } from './hinkal.types';
+export type ChartTimeBucket = '1h_1d' | '1h_1w' | '1d_1M' | '1d_1Y';
+export declare const dataBeefyApiConfig: {
+    base: string;
+    routes: {
+        prices: (oracleId: string, datePeriod: ChartTimeBucket) => string;
+        tvls: (vaultId: string, datePeriod: ChartTimeBucket) => string;
+        apys: (vaultId: string, datePeriod: ChartTimeBucket) => string;
+    };
+};
+export declare const isBeefyDeposit: (beefyAction: BeefyAction) => boolean;

package/types/big-intable.types.d.mts

@@ -0,0 +1,2 @@
+import { BigNumber } from 'ethers';
+export type BigIntable = BigNumber | string | number | boolean | bigint;

package/types/circom-data.types.d.mts

@@ -0,0 +1,70 @@
+export type CircomDataType = {
+    rootHashHinkal: bigint | undefined;
+    erc20TokenAddresses: string[];
+    tokenIds: string[];
+    amountChanges: bigint[];
+    inputNullifiers: string[][];
+    outCommitments: string[][];
+    encryptedOutputs: string[][];
+    flatFees: bigint[];
+    timeStamp?: string;
+    stealthAddressStructure: StealthAddressStructure;
+    rootHashAccessToken: bigint | undefined;
+    relay: string;
+    externalAddress: string;
+    externalActionMetadata: string;
+    externalActionId: bigint;
+    hookData: HookDataType;
+    calldataHash: bigint;
+    publicSignalCount: number;
+};
+export type CircomDataJsonType = {
+    rootHashHinkal: bigint | undefined | string;
+    erc20TokenAddresses: string[];
+    tokenIds: string[];
+    inputNullifiers: string[][];
+    outCommitments: string[][];
+    encryptedOutputs: string[][];
+    flatFees: bigint[] | string[];
+    amountChanges: bigint[] | string[];
+    stealthAddressStructure: StealthAddressStructure<bigint | string>;
+    timeStamp?: string;
+    rootHashAccessToken: bigint | undefined | string;
+    relay: string;
+    externalAddress: string;
+    externalActionMetadata: string;
+    externalActionId: bigint | string;
+    hookData: HookDataType;
+    calldataHash: bigint | string;
+    publicSignalCount: number;
+};
+export type DimDataType = {
+    tokenNumber: number;
+    nullifierAmount: number;
+    outputAmount: number;
+};
+export type HookDataType = {
+    hookContract: string;
+    preHookContract: string;
+    preHookMetadata: string;
+    postHookMetadata: string;
+};
+export type StealthAddressStructure<T = bigint> = {
+    extraRandomization: T;
+    stealthAddress: T;
+    H0: T;
+    H1: T;
+};
+export declare const emptyStealthAddressStructure: {
+    extraRandomization: string;
+    stealthAddress: string;
+    H0: string;
+    H1: string;
+};
+export interface TransactParams {
+    dimensions: DimDataType;
+    circomData: CircomDataType;
+}
+export declare const defaultHookData: HookDataType;
+export declare const defaultHookDataArray: string[];
+export declare const defaultStealthAddressStructure: StealthAddressStructure;

package/types/coingecko.types.d.mts

@@ -0,0 +1,8 @@
+export interface CoingeckoToken {
+    id: string;
+    symbol: string;
+    name: string;
+    platforms: {
+        [key: string]: string;
+    };
+}

package/types/commitments.types.d.mts

@@ -0,0 +1,26 @@
+import { BigIntable } from './big-intable.types';
+export interface EncryptedOutputWithSign<Sign = boolean> {
+    value: string;
+    isPositive: Sign;
+}
+export interface OutputsWithSignAndLast<Sign = boolean> {
+    additionalEncryptedOutputs: EncryptedOutputWithSign<Sign>[];
+    lastOutput: string;
+}
+export interface CommitmentEvent<BN = BigIntable> {
+    commitment: BN;
+    index: BN;
+    encryptedOutput: string;
+}
+export interface AccessTokenEvent<BN = BigIntable> {
+    accessKey: BN;
+    index: BN;
+    senderAddress: string;
+}
+export interface NullifierEvent<T> {
+    nullifier: T;
+}
+export interface RegisterEvent {
+    ethereumAddress: string;
+    shieldedAddressHash: string;
+}

package/types/connext.types.d.mts

@@ -0,0 +1,13 @@
+export type ConnextEstimateFeeParams = {
+    callDataGasAmount: number;
+    isHighPriority: boolean;
+    originDomain: number;
+    destinationDomain: number;
+};
+export type ConnextFeeData = {
+    type: string;
+    hex: string;
+};
+export type ConnextFeeResponse = {
+    receiveFeeAmount: string;
+};

package/types/crypto.types.d.mts

@@ -0,0 +1,7 @@
+export interface SignatureData {
+    r: string;
+    s: string;
+    v: string;
+    accessKey: string;
+    nonce: number;
+}

package/types/curve.types.d.mts

@@ -0,0 +1,133 @@
+export type Coins = {
+    address: string;
+    usdPrice: number;
+    decimals: string;
+    poolBalance: string;
+    symbol: string;
+    usdTotal?: number;
+    weighting?: number;
+};
+export type GaugeReward = {
+    tokenAddress: string;
+    symbol: string;
+    apy: number;
+};
+export type CurvePoolsType = {
+    id?: string;
+    name: string;
+    address: string;
+    lpToken: string;
+    lpTokenAddress: string;
+    coins: Coins[];
+    coinNames: string;
+    tokensForDeposit: Coins[];
+    coinAddresses: Array<string>;
+    coinLogos: Array<string>;
+    gaugeAddress?: string;
+    gaugeRewards?: GaugeReward[];
+    gaugeCrvApy?: {
+        base: number;
+        boosted: number;
+    };
+    usdTotal: number;
+    totalSupply: number;
+    lpPrice: number;
+    liquidityUtilization?: number;
+    tvl: number;
+    convexPoolData?: {
+        [id: string]: string | number | boolean;
+    };
+};
+export type CurveSubGraphType = {
+    address: string;
+    volumeUSD: number;
+    dailyApy: number;
+    weeklyApy: number;
+};
+export type CurvePoolsAllType = CurvePoolsType & CurveSubGraphType;
+export type PoolDataType = {
+    id?: string;
+    name: string;
+    address: string;
+    lpToken: string;
+    lpTokenAddress: string;
+    coins: Coins[];
+    tokensForDeposit: Coins[];
+    coinNames: string;
+    coinLogos: string[];
+    gaugeAddress?: string;
+    gaugeCrvApy?: {
+        base: number;
+        boosted: number;
+    };
+    gaugeRewards?: GaugeReward[];
+    usdTotal: number;
+    totalSupply: number;
+    lpPrice: number;
+    tvl: number;
+    volumeUSD: number;
+    liquidityUtilization?: number;
+    dailyApy: number;
+    weeklyApy: number;
+};
+export type CurvePoolExtendedInfo = {
+    poolAddress: any;
+    lpToken: any;
+    gaugeAddress: any;
+    gaugeCrvApy: any;
+    currencyReserves: any;
+    liquidityUtilization: any;
+    volumeUSD: number;
+    dailyApy: any;
+    weeklyApy: any;
+    A?: any;
+    initialA?: any;
+    futureA?: any;
+    futureTime?: any;
+    fee?: any;
+    daoFee?: any;
+    hasRampUp: boolean;
+    virtualPrice: any;
+    gaugeRewards?: GaugeReward[];
+};
+export declare const curveNetworkNames: {
+    [x: number]: string;
+};
+export declare const curvePools: readonly ["factory", "main", "crypto", "factory-crypto", "factory-crvusd", "factory-stable-ng", "factory-tricrypto"];
+export type CurvePoolType = {
+    [name: string]: {
+        shortName: string;
+        tag: string;
+    };
+};
+export type CurvePoolTypes = (typeof curvePools)[number];
+export type PoolDataKeyType = keyof PoolDataType;
+export type UpperTabPossibleSelections = 'DEPOSIT' | 'WITHDRAW/CLAIM';
+export declare const UpperTabPossibleValues: string[];
+export declare enum StatType {
+    Liquidity = "Liquidity",
+    Swaps = "Swaps"
+}
+export type CurvePoolResponse = {
+    id?: string;
+    address?: string;
+    name?: string;
+    coinsAddresses?: string[];
+    lpTokenAddress?: string;
+    totalSupply?: string;
+    usdTotal?: number;
+    gaugeCrvApy?: number[];
+    gaugeAddress?: string;
+    gaugeRewards?: GaugeReward[];
+    underlyingCoins?: Coins[];
+    coins?: Coins[];
+    volumeUSD?: number;
+    latestDailyApy?: number;
+    latestWeeklyApy?: number;
+};
+export type ConvexPoolResponse = {
+    id: string;
+    address: string;
+    lpTokenAddress: string;
+    convexPoolData: CurvePoolsType;
+};

package/types/duneAPI.types.d.mts

@@ -0,0 +1,9 @@
+export interface WalletBalancesInfo {
+    amount: number;
+    address: string;
+    chain: string;
+    chain_id: number;
+    symbol: string;
+    value_usd: number;
+    logoURI?: string;
+}