@dhedge/trading-widget 3.5.8-canary.2 → 3.6.0

package/core-kit/hooks/user/use-flatmoney-points-user-balances.d.ts

@@ -0,0 +1,10 @@
+interface UseFlatmoneyPointsUserBalancesData {
+    userPortionOfLockedPointsBalance: string;
+    unlockTaxAmount: string;
+    vestedPointsAmount: string;
+    unlockTimestamp: number | null;
+    unlockDate: string | null;
+    isLoading: boolean;
+}
+export declare const useFlatmoneyPointsUserBalances: () => UseFlatmoneyPointsUserBalancesData;
+export {};

package/core-kit/hooks/user/use-is-dhedge-vault-connected.d.ts

@@ -0,0 +1 @@
+export declare const useIsDhedgeVaultConnected: () => boolean;

package/core-kit/hooks/user/use-is-insufficient-balance.d.ts

@@ -0,0 +1 @@
+export declare const useIsInsufficientBalance: () => boolean;

package/core-kit/hooks/user/use-user-token-balance.d.ts

@@ -0,0 +1,8 @@
+import type { Address } from 'core-kit/types/web3.types';
+interface UserTokenBalanceParams {
+    symbol: string;
+    address: Address;
+    watch?: boolean;
+}
+export declare const useUserTokenBalance: ({ symbol, address, watch, }: UserTokenBalanceParams) => string;
+export {};

package/core-kit/hooks/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { useBrowserStorage } from './use-browser-storage';
+export { useDebounce } from './use-debounce';

package/core-kit/hooks/utils/use-browser-storage.d.ts

@@ -0,0 +1 @@
+export declare function useBrowserStorage<T>(storageType: 'sessionStorage' | 'localStorage', key: string, initialValue: T): [T, (value: T) => void];

package/core-kit/hooks/utils/use-debounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: <T>(value: T, delay: number) => T;

package/core-kit/hooks/web3/index.d.ts

@@ -0,0 +1,13 @@
+export { useConnect, useWriteContract, usePublicClient, useWaitForTransactionReceipt, useWalletClient, useSendTransaction, useReadContract, useReadContracts, useBlockNumber, useDisconnect, } from 'wagmi';
+export { useAccount } from './use-account';
+export { useNetwork } from './use-network';
+export { useTokenAllowance } from './use-token-allowance';
+export { useIsWalletConnected } from './use-is-wallet-connected';
+export { useBalance } from './use-balance';
+export { useContractFunction } from './use-contract-function';
+export { useGasPrice } from './use-gas-price';
+export { useContractReadsErrorLogging } from './use-contract-reads-error-logging';
+export { useContractReadErrorLogging } from './use-contract-read-error-logging';
+export { useStaticCallQuery } from './use-static-call-query';
+export { useInvalidateOnBlock } from './use-invalidate-on-block';
+export { useInvalidateTradingQueries } from './use-invalidate-trading-queries';

package/core-kit/hooks/web3/use-account.d.ts

@@ -0,0 +1,7 @@
+import { useAccount as useWagmiAccount } from 'wagmi';
+import type { Address } from 'core-kit/types';
+export declare const useAccount: () => Pick<import("wagmi").UseAccountReturnType<import("wagmi").Config>, "status" | "connector"> & {
+    account?: `0x${string}` | undefined;
+    providerName?: string | undefined;
+    isConnected: boolean;
+};

package/core-kit/hooks/web3/use-balance.d.ts

@@ -0,0 +1,2 @@
+import { useBalance as useWagmiBalance } from 'wagmi';
+export declare const useBalance: typeof useWagmiBalance;

package/core-kit/hooks/web3/use-contract-function.d.ts

@@ -0,0 +1,17 @@
+import type { ContractId } from 'core-kit/const';
+import type { Address, EstimateCall, UseWriteContractParameters } from 'core-kit/types/web3.types';
+interface ContractFunctionOptions {
+    contractId: ContractId;
+    functionName: string;
+    dynamicContractAddress?: Address;
+    onSettled?: Required<UseWriteContractParameters>['mutation']['onSettled'];
+}
+export declare const checkArgsForTxOverrides: (args: any[]) => {
+    transactionOverrides: any;
+    argumentsWithoutOverrides: any[];
+};
+export declare const useContractFunction: ({ functionName, dynamicContractAddress, contractId, onSettled, }: ContractFunctionOptions) => {
+    send: (...args: unknown[]) => Promise<void>;
+    estimate: EstimateCall;
+};
+export {};

package/core-kit/hooks/web3/use-contract-read-error-logging.d.ts

@@ -0,0 +1,6 @@
+interface UseContractReadErrorLoggingProps {
+    error: Error | null;
+    status: string;
+}
+export declare const useContractReadErrorLogging: ({ error, status, }: UseContractReadErrorLoggingProps) => void;
+export {};

package/core-kit/hooks/web3/use-contract-reads-error-logging.d.ts

@@ -0,0 +1,5 @@
+export interface UseContractReadsData {
+    error?: Error;
+    status: string;
+}
+export declare const useContractReadsErrorLogging: (data?: UseContractReadsData[]) => void;

package/core-kit/hooks/web3/use-gas-price.d.ts

@@ -0,0 +1,2 @@
+import { useEstimateFeesPerGas } from 'wagmi';
+export declare const useGasPrice: typeof useEstimateFeesPerGas;

package/core-kit/hooks/web3/use-invalidate-on-block.d.ts

@@ -0,0 +1,6 @@
+import type { UseReadContractsReturnType } from 'wagmi';
+export interface InvalidateOnBlockConfig {
+    queryKey: UseReadContractsReturnType['queryKey'];
+    watch?: boolean;
+}
+export declare const useInvalidateOnBlock: ({ queryKey, watch, }: InvalidateOnBlockConfig) => void;

package/core-kit/hooks/web3/use-invalidate-trading-queries.d.ts

@@ -0,0 +1,4 @@
+export declare const useInvalidateTradingQueries: () => {
+    invalidateAllowanceQueries: () => void;
+    invalidateTradingQueries: () => void;
+};

package/core-kit/hooks/web3/use-is-wallet-connected.d.ts

@@ -0,0 +1 @@
+export declare const useIsWalletConnected: () => boolean;

package/core-kit/hooks/web3/use-network.d.ts

@@ -0,0 +1,13 @@
+import { useAccount, useConfig, useSwitchChain } from 'wagmi';
+import type { ChainId } from 'core-kit/types/web3.types';
+interface UseNetworkData {
+    chain: ReturnType<typeof useAccount>['chain'];
+    chains: ReturnType<typeof useConfig>['chains'];
+    switchNetwork: ReturnType<typeof useSwitchChain>['switchChain'];
+    switchNetworkAsync: ReturnType<typeof useSwitchChain>['switchChainAsync'];
+    isSupported: boolean;
+    chainId: ChainId | undefined;
+    supportedChainId: ChainId;
+}
+export declare const useNetwork: () => UseNetworkData;
+export {};

package/core-kit/hooks/web3/use-static-call-query.d.ts

@@ -0,0 +1,13 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { usePublicClient } from 'wagmi';
+import type { UseReadContractParameters } from 'wagmi';
+type UseStaticCallVariables = Pick<Required<UseReadContractParameters>, 'functionName' | 'abi' | 'address' | 'chainId'> & {
+    disabled?: boolean;
+    args: unknown[];
+    refetchInterval?: number;
+};
+export declare const makeStaticCall: <T>({ functionName, address, abi, args, publicClient, }: Omit<UseStaticCallVariables, "chainId" | "refetchInterval" | "disabled"> & {
+    publicClient: ReturnType<typeof usePublicClient>;
+}) => Promise<T | undefined>;
+export declare const useStaticCallQuery: <T>({ disabled, functionName, address, abi, args, chainId, refetchInterval, }: UseStaticCallVariables) => UseQueryResult<T>;
+export {};

package/core-kit/hooks/web3/use-token-allowance.d.ts

@@ -0,0 +1,9 @@
+import { useReadContract } from 'core-kit/hooks/web3';
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+export declare const useTokenAllowance: ({ tokenAddress, ownerAddress, spenderAddress, chainId, skip, }: {
+    tokenAddress: Address;
+    ownerAddress: Address;
+    spenderAddress: Address;
+    chainId: ChainId;
+    skip?: boolean | undefined;
+}) => ReturnType<typeof useReadContract>;

package/core-kit/index.d.ts

@@ -0,0 +1 @@
+export { TradingPanelProvider, getDefaultTradingPanelState } from './providers';

package/core-kit/models/estimation-error.d.ts

@@ -0,0 +1,20 @@
+import { CustomError } from 'ts-custom-error';
+interface EstimationErrorParams {
+    txArgs: unknown[];
+    account?: string;
+    message?: string;
+    link?: string;
+    slippage?: number | 'auto';
+    functionName?: string;
+    onBypass?: () => void;
+}
+export declare class EstimationError extends CustomError {
+    txArgs: unknown[];
+    link?: string;
+    account?: string;
+    slippage?: number | 'auto';
+    functionName?: string;
+    onBypass?: () => void;
+    constructor({ message, link, slippage, txArgs, account, onBypass, functionName, }: EstimationErrorParams);
+}
+export {};

package/core-kit/models/index.d.ts

@@ -0,0 +1 @@
+export { EstimationError } from './estimation-error';

package/core-kit/providers/index.d.ts

@@ -0,0 +1,6 @@
+import type { FC, PropsWithChildren } from 'react';
+import type { TradingPanelActionsState, TradingPanelContextConfig, TradingPanelState } from 'core-kit/types/state.types';
+export declare const getDefaultTradingPanelState: (config?: Partial<TradingPanelState>) => TradingPanelState;
+export declare const TradingPanelStateContext: import("react").Context<TradingPanelState>;
+export declare const TradingPanelActionsContext: import("react").Context<TradingPanelActionsState>;
+export declare const TradingPanelProvider: FC<PropsWithChildren<TradingPanelContextConfig>>;

package/core-kit/types/config.types.d.ts

@@ -0,0 +1,33 @@
+import type { PoolComposition } from 'core-kit/types/pool.types';
+import type { ApyCurrency, TradingToken } from 'core-kit/types/trading-panel.types';
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+export interface PoolConfig {
+    address: Address;
+    symbol: string;
+    chainId: ChainId;
+    depositParams: {
+        customTokens: TradingToken[];
+        defaultDepositTokenSymbol?: string;
+    };
+    withdrawParams: {
+        customTokens: TradingToken[];
+    };
+    deprecated?: boolean;
+    maintenance?: boolean;
+    maintenanceDeposits?: boolean;
+    maintenanceWithdrawals?: boolean;
+}
+export interface PoolFallbackData {
+    address: Address;
+    managerLogicAddress?: Address;
+    poolCompositions?: PoolComposition[];
+    tokenPrice?: string;
+    apy?: {
+        value: number;
+        currency: ApyCurrency;
+    };
+    performanceFeeNumerator?: string | null;
+    streamingFeeNumerator?: string | null;
+    entryFeeNumerator?: string | null;
+    exitFeeNumerator?: string | null;
+}

package/core-kit/types/contract.types.d.ts

@@ -0,0 +1,28 @@
+import type { Address } from 'viem';
+export interface DynamicPoolContractData {
+    userBalance: string | undefined;
+    tokenPrice: string | undefined;
+    getExitRemainingCooldown: string | undefined;
+    totalValue: string | undefined;
+    totalSupply: string | undefined;
+    isPrivateVault: boolean | undefined;
+    performanceFee: string | undefined;
+    streamingFee: string | undefined;
+    entryFee: string | undefined;
+    exitFee: string | undefined;
+    managerAddress: string | undefined;
+}
+type AssetStructure = {
+    asset: Address;
+    amount: bigint;
+};
+export interface CalculateSwapDataParamsResponse {
+    srcData: AssetStructure[];
+    dstData: AssetStructure;
+}
+export interface ComplexWithdrawAssetData {
+    supportedAsset: Address;
+    withdrawData: string;
+    slippageTolerance: bigint;
+}
+export {};

package/core-kit/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from './config.types';
+export * from './contract.types';
+export * from './pool.types';
+export * from './referral.types';
+export * from './state.types';
+export * from './trading.types';
+export * from './trading-panel.types';
+export * from './web3.types';
+export * from './synthetix-v3.types';
+export * from './react-query.types';

package/core-kit/types/pool.types.d.ts

@@ -0,0 +1,17 @@
+import type { Address } from 'core-kit/types/web3.types';
+export interface PoolComposition {
+    tokenName: string;
+    rate: string;
+    amount: string;
+    isDeposit: boolean;
+    tokenAddress: Address;
+    precision: number;
+    asset: {
+        iconSymbols: string[];
+    };
+}
+export interface PoolCompositionWithFraction extends PoolComposition {
+    fraction: string;
+    fractionUsd: string;
+    fractionUsdNumber: number;
+}

package/core-kit/types/react-query.types.d.ts

@@ -0,0 +1,11 @@
+export type ContractReadQueryKey = ['readContract', {
+    functionName?: string;
+}];
+export type ContractReadsQueryKey = [
+    'readContracts',
+    {
+        contracts?: {
+            functionName?: string;
+        }[];
+    }
+];

package/core-kit/types/referral.types.d.ts

@@ -0,0 +1,12 @@
+export interface TagInvestorByReferrerCallbackVariables {
+    poolAddress: string;
+    referrerAddress: string;
+    investorAddress: string;
+}
+export interface UseReferralProgramProps {
+    vaultAddress: string;
+    userAddress?: string | null;
+    query: Record<string, string | string[] | undefined>;
+    logEvent?: () => void;
+    tagInvestorByReferrer: (data: TagInvestorByReferrerCallbackVariables) => Promise<unknown>;
+}

package/core-kit/types/state.types.d.ts

@@ -0,0 +1,109 @@
+import type { EstimationError } from 'core-kit/models';
+import type { PoolConfig, PoolFallbackData } from 'core-kit/types/config.types';
+import type { DynamicTradingToken, PendingTransaction, TokenSelectorPayload, TradingModalStatus, TradingPanelType, TradingToken, TransactionAction, UpdateTransactionsArguments } from 'core-kit/types/trading-panel.types';
+import type { SwapDataRequest, SwapDataResponse } from 'core-kit/types/trading.types';
+import type { Address, ChainId, SimulateTransactionParams, SimulateTransactionResponse, WaitForTransactionReceiptReturnType } from 'core-kit/types/web3.types';
+export interface TradingPanelStateModal {
+    isOpen: boolean;
+    status: TradingModalStatus;
+    action?: TransactionAction;
+    link?: string;
+    sendTokens: TradingToken[] | null;
+    receiveTokens: TradingToken[] | null;
+    meta?: {
+        withdrawPercentage?: number;
+    };
+}
+export interface TradingPanelState {
+    settings: {
+        slippage: number | 'auto';
+        minSlippage?: number;
+        isInfiniteAllowance: boolean;
+        isMultiAssetWithdrawalEnabled: boolean;
+        isMaxSlippageLoading: boolean;
+    };
+    type: TradingPanelType;
+    input: {
+        sendToken: DynamicTradingToken;
+        receiveToken: DynamicTradingToken;
+    };
+    modal: TradingPanelStateModal;
+    poolAddress: PoolConfig['address'];
+    poolConfigMap: Record<PoolConfig['address'], PoolConfig>;
+    transactions: PendingTransaction[];
+    poolFallbackData: PoolFallbackData;
+    defaultChainId?: ChainId;
+}
+export interface TradingPanelSetters {
+    setPoolAddress: (payload: TradingPanelState['poolAddress']) => void;
+    updateSendTokenInput: (payload: Partial<DynamicTradingToken>) => void;
+    updateReceiveTokenInput: (payload: Partial<DynamicTradingToken>) => void;
+    updateTradingSettings: (payload: Partial<TradingPanelState['settings']>) => void;
+    setTradingType: (payload: TradingPanelState['type']) => void;
+    updateTradingModal: (payload: Partial<TradingPanelState['modal']>) => void;
+    updateTransactions: (payload: UpdateTransactionsArguments) => void;
+    updatePoolFallbackData: (payload: PoolFallbackData) => void;
+    updatePoolConfig: (payload: Record<PoolConfig['address'], Pick<PoolConfig, 'maintenance' | 'maintenanceDeposits' | 'maintenanceWithdrawals'>>) => void;
+}
+export interface CallbackConfig {
+    onSetPoolAddress: TradingPanelSetters['setPoolAddress'];
+    onUpdateSendTokenInput: TradingPanelSetters['updateSendTokenInput'];
+    onUpdateReceiveTokenInput: TradingPanelSetters['updateReceiveTokenInput'];
+    onUpdateTradingSettings: TradingPanelSetters['updateTradingSettings'];
+    onSetTradingType: TradingPanelSetters['setTradingType'];
+    onUpdateTradingModal: TradingPanelSetters['updateTradingModal'];
+    onUpdateTransactions: TradingPanelSetters['updateTransactions'];
+    onTradingSettleError: (error: Error) => void;
+    onTransactionError: (error: Error, action: TransactionAction | undefined, chainId?: ChainId, txHash?: Address) => void;
+    onTransactionSuccess: (data: WaitForTransactionReceiptReturnType, action: TransactionAction | undefined, link?: string) => void;
+    onTransactionEstimationError: (error: EstimationError, address: Address, chainId: ChainId, account?: Address) => void;
+    onTokenSelector: (payload: TokenSelectorPayload) => void;
+    onLog: (eventName: string, payload?: Record<string, unknown>) => void;
+    onSimulateTransaction: (params: SimulateTransactionParams) => Promise<SimulateTransactionResponse | null>;
+    getSwapData: (args: {
+        signal: AbortSignal;
+        variables: SwapDataRequest;
+    }) => Promise<SwapDataResponse | null>;
+}
+export type TradingPanelAction = {
+    type: 'SET_POOL_ADDRESS';
+    payload: TradingPanelState['poolAddress'];
+} | {
+    type: 'SET_TRADING_TYPE';
+    payload: TradingPanelState['type'];
+} | {
+    type: 'UPDATE_SEND_TOKEN_INPUT';
+    payload: Partial<DynamicTradingToken>;
+} | {
+    type: 'UPDATE_RECEIVE_TOKEN_INPUT';
+    payload: Partial<DynamicTradingToken>;
+} | {
+    type: 'UPDATE_TRADING_SETTINGS';
+    payload: Partial<TradingPanelState['settings']>;
+} | {
+    type: 'UPDATE_TRADING_MODAL';
+    payload: Partial<TradingPanelState['modal']>;
+} | {
+    type: 'UPDATE_TRADING_TRANSACTIONS';
+    payload: UpdateTransactionsArguments;
+} | {
+    type: 'UPDATE_POOL_FALLBACK_DATA';
+    payload: PoolFallbackData;
+} | {
+    type: 'UPDATE_POOL_CONFIG';
+    payload: Record<PoolConfig['address'], Pick<PoolConfig, 'maintenance' | 'maintenanceDeposits' | 'maintenanceWithdrawals'>>;
+};
+export interface TradingPanelContextConfig {
+    actions: Partial<CallbackConfig> & Pick<CallbackConfig, 'getSwapData'>;
+    initialState?: Partial<TradingPanelState>;
+}
+export type TradingPanelActionsState = TradingPanelSetters & {
+    onTradingSettleError: CallbackConfig['onTradingSettleError'] | undefined;
+    onTransactionError: CallbackConfig['onTransactionError'] | undefined;
+    onTransactionSuccess: CallbackConfig['onTransactionSuccess'] | undefined;
+    onTransactionEstimationError: CallbackConfig['onTransactionEstimationError'] | undefined;
+    onTokenSelector: CallbackConfig['onTokenSelector'] | undefined;
+    onLog: CallbackConfig['onLog'] | undefined;
+    onSimulateTransaction: CallbackConfig['onSimulateTransaction'] | undefined;
+    getSwapData: CallbackConfig['getSwapData'];
+};

package/core-kit/types/synthetix-v3.types.d.ts

@@ -0,0 +1,15 @@
+import type { Address, Hex, PublicClient, TransactionRequest } from 'core-kit/types/web3.types';
+export interface OracleAdapter {
+    getOracleId: () => string;
+    fetchOffchainData: (client: PublicClient | undefined, oracleContract: Address, oracleQuery: Array<{
+        query: Hex;
+        fee: bigint;
+    }> | undefined) => Promise<Array<{
+        arg: Hex;
+        fee?: bigint;
+    }>>;
+}
+export interface Batcher {
+    batchable: (client: PublicClient, transactions: TransactionRequest[]) => Promise<boolean>;
+    batch: (transactions: TransactionRequest[]) => TransactionRequest;
+}

package/core-kit/types/trading-panel.types.d.ts

@@ -0,0 +1,43 @@
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+export interface TradingToken {
+    address: Address;
+    symbol: string;
+    value: string;
+    decimals: number;
+}
+export interface DynamicTradingToken extends TradingToken {
+    isLoading?: boolean;
+}
+export type TradingModalStatus = 'Success' | 'None' | 'Mining' | 'Wallet';
+export interface PendingTransaction {
+    action: TransactionAction;
+    symbol: string;
+    chainId: ChainId;
+    txHash?: Address;
+}
+type AddTransaction = {
+    type: 'add';
+} & PendingTransaction;
+type UpdateTransaction = {
+    type: 'update';
+} & Partial<PendingTransaction>;
+type RemoveTransaction = {
+    type: 'remove';
+    status: 'success' | 'fail';
+} & Partial<PendingTransaction>;
+export type UpdateTransactionsArguments = AddTransaction | UpdateTransaction | RemoveTransaction;
+export type TradingPanelType = 'deposit' | 'withdraw';
+export type TransactionAction = 'deposit' | 'multi_withdraw' | 'single_withdraw' | 'approve' | 'oraclesUpdate' | 'swap' | 'claim' | 'single_withdraw_and_claim';
+export type SwapEntity = 'token' | 'pool';
+export interface TokenSelectorPayload {
+    isOpen: boolean;
+    entity: SwapEntity;
+}
+export type ApyCurrency = 'USD' | 'ETH';
+export interface UseProjectedEarningsResult {
+    dailyEarnings: string | null;
+    monthlyEarnings: string | null;
+    yearlyEarnings: string | null;
+    showEarnings: boolean;
+}
+export {};

package/core-kit/types/trading.types.d.ts

@@ -0,0 +1,32 @@
+import type { Hex } from 'viem';
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+export type NativeTokenSymbol = 'ETH' | 'POL';
+export type ChainNativeTokenMap = {
+    [key in ChainId]?: {
+        nativeTokenSymbol: NativeTokenSymbol;
+        wrappedNativeTokenName: string;
+        address: Address;
+        decimals: number;
+    };
+};
+export interface SwapDataResponse {
+    destinationAmount: string;
+    rawTransaction: {
+        data: Hex;
+    };
+    routerKey: 'ONE_INCH' | 'ZERO_X' | 'PARASWAP' | 'ONE_INCH_V5' | 'PARASWAP_V6' | 'ODOS_V2';
+}
+export interface SwapDataRequest {
+    chainId: number;
+    sourceAddress: Address;
+    destinationAddress: Address;
+    walletAddress: Address;
+    fromAddress: Address;
+    amount: string;
+    slippage: string;
+}
+export interface VaultDepositParams {
+    depositMethod: DepositMethodName;
+    vaultDepositTokenAddress: Address;
+}
+export type DepositMethodName = 'deposit' | 'depositWithCustomCooldown' | 'nativeDeposit' | 'nativeDepositWithCustomCooldown' | 'zapNativeDeposit' | 'zapNativeDepositWithCustomCooldown' | 'zapDeposit' | 'zapDepositWithCustomCooldown';

package/core-kit/types/web3.types.d.ts

@@ -0,0 +1,34 @@
+import type { Address, Chain, TransactionRequest as ViemTransactionRequest } from 'viem';
+export type { UseWriteContractParameters, UseReadContractsParameters, } from 'wagmi';
+export type { Hex, PublicClient, WalletClient, Client, WaitForTransactionReceiptReturnType, CallExecutionError, MulticallReturnType, Hash, ContractFunctionReturnType, } from 'viem';
+export type { Address, Chain };
+export type ChainId = Chain['id'];
+export type TransactionRequest = Pick<ViemTransactionRequest, 'to' | 'data' | 'value' | 'from'>;
+export type ContractActionFunc = () => Promise<void | unknown>;
+export interface EstimatedGas {
+    value: bigint;
+    error: string;
+}
+export type EstimateCall = (...args: unknown[]) => Promise<EstimatedGas>;
+export interface SimulateTransactionParams {
+    chainId: ChainId;
+    from: Address;
+    to: Address;
+    input: string;
+    gas: number;
+    value?: string;
+}
+export interface SimulateTransactionResponse {
+    link?: string;
+    simulation: {
+        status: boolean;
+        error_message: string;
+    };
+}
+export interface PoolContractCallParams {
+    address: Address;
+    chainId: ChainId;
+}
+export interface PoolContractAccountCallParams extends PoolContractCallParams {
+    account: Address;
+}

package/core-kit/utils/common.d.ts

@@ -0,0 +1,4 @@
+export declare const sliceByIndex: <T>(data: T[], index: number) => {
+    firstPart: T[];
+    secondPart: T[];
+};

package/core-kit/utils/error.d.ts

@@ -0,0 +1,17 @@
+type ErrorWithMessage = {
+    message: string;
+};
+export declare const isErrorWithMessage: (error: unknown) => error is ErrorWithMessage;
+export declare const toErrorWithMessage: (maybeError: unknown) => ErrorWithMessage;
+export declare const getErrorMessage: (error: unknown) => string;
+export declare const validateLoggerEventParams: (paramsMap: Record<string, {
+    type: 'string' | 'number';
+}>) => boolean;
+export declare const parseContractErrorMessage: ({ errorMessage, abiErrors, }: {
+    errorMessage: string | undefined | null;
+    abiErrors: string[];
+}) => {
+    title: string;
+    hint?: string | undefined;
+} | null;
+export {};

package/core-kit/utils/flat-money.d.ts

@@ -0,0 +1,9 @@
+import type { Address } from 'viem';
+export declare const isFmpAirdropVaultAddress: (address: Address) => boolean;
+export declare const isFlatMoneyLeveragedAsset: (address: Address) => boolean;
+export declare const getFlatMoneyCollateralByLeverageAddress: (address: string) => {
+    symbol: string;
+    decimals: number;
+    address: string;
+};
+export declare const getFlatMoneyLinkByUnitAddress: (address: string) => "https://flat.money/flatcoin" | "https://v1.flat.money/flatcoin";

package/core-kit/utils/formatter.d.ts

@@ -0,0 +1,17 @@
+import type { ApyCurrency } from 'core-kit/types';
+export declare const formatPercentage: (value: number, maximumFractionDigits?: number) => string;
+export declare const formatToUsd: ({ value, minimumFractionDigits, maximumFractionDigits, compact, normalize, }: {
+    value: number | string;
+    minimumFractionDigits?: number | undefined;
+    maximumFractionDigits?: number | undefined;
+    compact?: boolean | undefined;
+    normalize?: boolean | undefined;
+}) => string;
+export declare const formatNumeratorToPercentage: (numerator: number | string, denominator: number, maximumFractionDigits?: number) => string;
+export declare const removeInsignificantTrailingZeros: (value: string) => string;
+export declare const formatNumberToLimitedDecimals: (value: number | string, decimals: number) => string;
+export declare const formatByCurrency: ({ currency, value, }: {
+    currency: ApyCurrency;
+    value: number;
+}) => string;
+export declare const formatBalance: (value: string, precision: number) => string;

package/core-kit/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from './common';
+export * from './url';
+export * from './web3';
+export * from './number';
+export * from './transaction';
+export * from './token';
+export * from './error';
+export * from './formatter';
+export * from './synthetix';
+export * from './ua';
+export * from './flat-money';
+export * from './logger';

package/core-kit/utils/logger.d.ts

@@ -0,0 +1,17 @@
+import type { TradingPanelActionsState, TransactionAction } from 'core-kit/types';
+import type { Address } from 'core-kit/types/web3.types';
+/**
+ * Transforms an Ethereum address to ensure it's treated as a string in Firebase Analytics.
+ * Adds a prefix to avoid scientific notation or numeric interpretation.
+ *
+ * @param {string} ethereumAddress - The Ethereum address to transform.
+ * @returns {string} - The transformed Ethereum address.
+ */
+export declare const transformAddressForAnalytics: (ethereumAddress: Address) => string;
+export declare const logTransactionByActionType: ({ action, log, symbol, vaultAddress, chainId, }: {
+    action: TransactionAction;
+    symbol: string;
+    log: TradingPanelActionsState['onLog'];
+    chainId: number;
+    vaultAddress: Address;
+}) => void;