@pyxisjs/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,821 @@
+import { InputEntryFunctionData, AptosSettings } from '@aptos-labs/ts-sdk';
+
+/**
+ * Chain types for multi-chain support
+ */
+declare enum NetworkType {
+    MAINNET = "mainnet",
+    TESTNET = "testnet"
+}
+declare enum ChainId {
+    APTOS_MAINNET = "aptos-mainnet",
+    APTOS_TESTNET = "aptos-testnet",
+    ETHEREUM_MAINNET = "ethereum-mainnet",
+    ETHEREUM_SEPOLIA = "ethereum-sepolia",
+    ARBITRUM_ONE = "arbitrum-one"
+}
+declare enum ChainType {
+    EVM = "evm",
+    MoveVM = "move_vm"
+}
+interface Currency {
+    /** The symbol of the currency (e.g., 'APT', 'ETH') */
+    symbol: string;
+    /** The number of decimal places */
+    decimals: number;
+    /** The full name of the currency */
+    name: string;
+}
+interface Chain {
+    /** Unique identifier for the chain */
+    readonly id: ChainId;
+    /** RPC URL for the chain */
+    readonly rpcUrl: string;
+    /** Optional indexer URL for Aptos chains */
+    readonly indexerUrl?: string;
+    /** Optional API key for authenticated access */
+    readonly apiKey?: string;
+    /** Optional contract addresses for vault operations */
+    readonly contractAddresses?: VaultContractAddressConfig;
+}
+interface ChainConfig {
+    type: ChainType;
+    networkType: NetworkType;
+    name: string;
+    chainId?: number;
+    nativeCurrency: Currency;
+    blockExplorerUrls?: string[];
+    isTestnet: boolean;
+}
+declare const CHAIN_CONFIGS: Record<ChainId, ChainConfig>;
+declare function getChainConfig(chainId: ChainId): ChainConfig;
+interface VaultContractAddressConfig {
+    /** Address of the accountant contract responsible for managing vault accounting */
+    accountant: string;
+    /** Address of the teller contract responsible for handling deposits and withdrawals */
+    teller: string;
+    /** Address of the atomic queue contract for managing transaction ordering */
+    atomicQueue: string;
+}
+
+/**
+ * Transaction payload types
+ */
+interface EthereumJsonRpcRequest {
+    method: 'eth_sendTransaction';
+    params: Array<{
+        to?: string;
+        from?: string;
+        data?: string;
+        value?: string;
+    }>;
+}
+interface AptosTransactionPayload {
+    function: `${string}::${string}::${string}`;
+    typeArguments: string[];
+    functionArguments: any[];
+}
+type TransactionPayload = {
+    type: 'evm';
+    data: EthereumJsonRpcRequest;
+} | {
+    type: 'aptos';
+    data: AptosTransactionPayload;
+};
+
+/**
+ * Wallet types for multi-chain support
+ */
+
+interface WalletAccount {
+    /** Address of the account */
+    address: string;
+    /** Public key of the account */
+    publicKey?: string;
+    /** Name of the account (optional) */
+    name?: string;
+}
+
+interface WalletAdapter {
+    /**
+     * Sign and submit a transaction
+     */
+    signAndSubmitTransaction(transaction: TransactionPayload): Promise<{
+        hash: string;
+    }>;
+}
+/**
+ * Base transaction interface for all chains
+ */
+interface BaseTransaction<T = any> {
+    /** Unique identifier for the transaction */
+    hash: string;
+    /** Transaction data */
+    data: T;
+}
+/**
+ * Aptos-specific transaction
+ */
+interface AptosTransaction extends BaseTransaction<InputEntryFunctionData> {
+}
+/**
+ * Ethereum-specific transaction
+ */
+interface EthereumTransaction extends BaseTransaction {
+    type: 'ethereum';
+    to: string;
+    data: string;
+    value: string;
+    gasLimit: string;
+    gasPrice?: string;
+}
+/**
+ * Union type for transactions across all chains
+ */
+type AnyTransaction = AptosTransaction | EthereumTransaction;
+/**
+ * Signed transaction interface
+ */
+interface SignedTransaction {
+    /** Transaction hash */
+    hash: string;
+    /** Serialized transaction data */
+    serialized: any;
+    /** Chain this transaction is for */
+    chain: string;
+}
+/**
+ * Transaction result interface
+ */
+interface TransactionResult {
+    /** Transaction hash */
+    hash: string;
+    /** Whether transaction was successful */
+    success: boolean;
+    /** Block number (if applicable) */
+    blockNumber?: number;
+    /** Block timestamp */
+    blockTimestamp?: number;
+    /** Gas used (EVM only) */
+    gasUsed?: string;
+    /** Error message if transaction failed */
+    error?: string;
+}
+
+/**
+ * Configuration options for the Pyxis SDK
+ * @deprecated Use MultiChainSDKConfig instead
+ */
+interface SDKConfig {
+    /** Contract addresses */
+    contractAddresses?: VaultContractAddressConfig;
+    /** Event indexer config */
+    eventIndexerConfig: AptosSettings;
+    /** Main indexer config */
+    aptosIndexerConfig: AptosSettings;
+}
+
+/**
+ * Interface representing the state of request flags
+ */
+interface PyxisRequestFlagState {
+    /** bit 0 (1): deadline passed (`now > deadline`) */
+    deadlinePassed: boolean;
+    /** bit 1 (2): zero offer amount (escrow balance is zero) */
+    zeroOfferAmount: boolean;
+    /** bit 2 (4): minimum age not met (`now - updated_at < minimum_request_age`) */
+    minimumAgeNotMet: boolean;
+}
+/**
+ * Interface representing a token with inner value
+ */
+interface PyxisToken {
+    /** Inner token value */
+    inner: string;
+}
+/**
+ * Interface representing a withdrawal request
+ */
+interface PyxisOnchainWithdrawalRequest {
+    /** Atomic price for the withdrawal */
+    atomic_price: string;
+    /** Deadline timestamp for the request */
+    deadline: string;
+    /** Request flags */
+    flags?: {
+        flag: number;
+    };
+    /** Amount being offered */
+    offer_amount: string;
+    /** Token being offered */
+    offer_token: PyxisToken;
+    /** User address making the withdrawal request */
+    user_address: string;
+    /** Amount wanted in return */
+    want_amount: string;
+    /** Token wanted in return */
+    want_token: PyxisToken;
+}
+/**
+ * Interface representing a withdrawal request with camelCase properties
+ */
+interface PyxisWithdrawalRequest {
+    /** Atomic price for the withdrawal */
+    atomicPrice: string;
+    /** Deadline timestamp for the request */
+    deadline: string;
+    /** Request flags parsed into a RequestFlagState object */
+    flags: PyxisRequestFlagState;
+    /** Amount being offered */
+    offerAmount: string;
+    /** Token being offered */
+    offerToken: PyxisToken;
+    /** User address making the withdrawal request */
+    userAddress: string;
+    /** Amount wanted in return */
+    wantAmount: string;
+    /** Token wanted in return */
+    wantToken: PyxisToken;
+    /** Timestamp when the withdrawal request was last updated */
+    updatedAt: string;
+}
+interface BuildWithdrawTxArgs {
+    vault: string;
+    offerAsset: string;
+    wantAsset: string;
+    offerAmount: string;
+    price: string;
+    deadline: string;
+}
+interface BuildReclaimWithdrawalRequestTxArgs {
+    vault: string;
+    offerAsset: string;
+    wantAsset: string;
+}
+interface BuildCancelWithdrawalRequestTxArgs {
+    vault: string;
+    offerAsset: string;
+    wantAsset: string;
+}
+interface BuildDepositTxArgs {
+    vault: string;
+    asset: string;
+    amount: string;
+    minimumMint: string;
+}
+interface GetWithdrawRateInQuoteSafeArgs {
+    vault: string;
+    quoteAsset: string;
+}
+interface QuoteDepositArgs {
+    vault: string;
+    asset: string;
+    amount: string;
+}
+interface QuoteWithdrawArgs {
+    vault: string;
+    amount: string;
+    wantAsset: string;
+}
+interface GetDepositRateInQuoteSafeArgs {
+    vault: string;
+    quoteAsset: string;
+}
+interface GetMinimumRequestAgeArgs {
+    vault: string;
+}
+/**
+ * Arguments for the getWithdrawalRequestsOfUser function
+ */
+interface GetWithdrawalRequestsOfUserArgs {
+    /** The vault address to query */
+    vault: string;
+    /** The user address to query for withdrawal requests */
+    userAddress: string;
+    /** The request flag state to filter by */
+    flag: PyxisRequestFlagState;
+    /** Whether to match all flags or any flag */
+    matchAll?: boolean;
+}
+interface GetActivitiesArgs {
+    /** The vault address to filter activities by */
+    vault?: string;
+    /** The user address to filter activities by */
+    user?: string;
+    /** The page number for pagination */
+    page?: number;
+    /** The number of items per page for pagination */
+    pageSize?: number;
+}
+interface IndexerVaultActivity {
+    /** The amount deposited in the activity */
+    deposit_amount: string | null;
+    /** The token type deposited in the activity */
+    deposit_token: string | null;
+    /** The type of event (deposit, withdrawal, etc.) */
+    event_type: string;
+    /** The transaction hash */
+    tx_hash: string;
+    /** The transaction version */
+    tx_version: string;
+    /** The timestamp when the activity occurred */
+    tx_timestamp: string;
+    /** The user address who performed the activity */
+    user: string;
+    /** The vault address where the activity occurred */
+    vault: string;
+    /** The amount withdrawn in the activity */
+    withdraw_amount: string | null;
+    /** The token type withdrawn in the activity */
+    withdraw_token: string | null;
+}
+interface VaultActivity {
+    /** The amount deposited in the activity */
+    depositAmount: string | null;
+    /** The token type deposited in the activity */
+    depositToken: string | null;
+    /** The type of event (deposit, withdrawal, etc.) */
+    eventType: string;
+    /** The transaction hash */
+    txHash: string;
+    /** The transaction version */
+    txVersion: string;
+    /** The timestamp when the activity occurred */
+    txTimestamp: string;
+    /** The user address who performed the activity */
+    user: string;
+    /** The vault address where the activity occurred */
+    vault: string;
+    /** The amount withdrawn in the activity */
+    withdrawAmount: string | null;
+    /** The token type withdrawn in the activity */
+    withdrawToken: string | null;
+}
+interface VaultTvlArgs {
+    /** The vault address to get TVL for */
+    vault: string;
+    /** The asset to denominate the TVL in
+     * Should be the base asset of the vault
+     */
+    asset: string;
+}
+interface IndexerExchangeRateEvent {
+    /** The timestamp when the exchange rate event occurred */
+    current_time: string;
+    /** The new deposit rate after the event */
+    new_deposit_rate: string;
+    /** The new withdrawal rate after the event */
+    new_withdraw_rate: string;
+    /** The previous deposit rate before the event */
+    old_deposit_rate: string;
+    /** The previous withdrawal rate before the event */
+    old_withdraw_rate: string;
+    /** The vault address where the exchange rate event occurred */
+    vault: string;
+    /** The type of the exchange rate event */
+    type: string;
+}
+interface ExchangeRateEvent {
+    /** The timestamp when the exchange rate event occurred */
+    timestamp: string;
+    /** The new deposit rate after the event */
+    newDepositRate: string;
+    /** The new withdrawal rate after the event */
+    newWithdrawRate: string;
+    /** The previous deposit rate before the event */
+    oldDepositRate: string;
+    /** The previous withdrawal rate before the event */
+    oldWithdrawRate: string;
+    /** The vault address where the exchange rate event occurred */
+    vault: string;
+    /** The type of the exchange rate event */
+    type: string;
+}
+interface HistoricalApyArgs {
+    /** The vault address to get APY for */
+    vault: string;
+    /** The start time of the range (timestamp in seconds) */
+    startTime: number;
+    /** The end time of the range (timestamp in seconds) */
+    endTime: number;
+    /** The window length of the range to calculate APY (e.g., 7d, 30d, alltime) */
+    window?: ApyWindow;
+}
+type ApyWindow = '7d' | '30d' | 'alltime';
+interface ApyDataPoint {
+    /** The APY value as a percentage string */
+    value: string;
+    /** The timestamp in seconds */
+    timestamp: string;
+}
+
+/**
+ * Base error class for all Pyxis SDK errors
+ */
+declare class PyxisError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, details?: Record<string, unknown>);
+}
+/**
+ * Network-related errors (blockchain connectivity, RPC issues, etc.)
+ */
+declare class NetworkError extends PyxisError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Input validation errors
+ */
+declare class ValidationError extends PyxisError {
+    readonly field: string | undefined;
+    constructor(message: string, field?: string, details?: Record<string, unknown>);
+}
+/**
+ * Insufficient funds errors
+ */
+declare class InsufficientFundsError extends PyxisError {
+    readonly requiredAmount: string;
+    readonly availableAmount: string;
+    readonly tokenType: string;
+    constructor(message: string, requiredAmount: string, availableAmount: string, tokenType: string);
+}
+/**
+ * Wallet connection errors
+ */
+declare class WalletError extends PyxisError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Smart contract interaction errors
+ */
+declare class ContractError extends PyxisError {
+    readonly contractAddress: string | undefined;
+    readonly functionName: string | undefined;
+    constructor(message: string, contractAddress?: string, functionName?: string, details?: Record<string, unknown>);
+}
+/**
+ * Transaction-related errors
+ */
+declare class TransactionError extends PyxisError {
+    readonly txHash: string | undefined;
+    constructor(message: string, txHash?: string, details?: Record<string, unknown>);
+}
+/**
+ * Vault-specific errors
+ */
+declare class VaultError extends PyxisError {
+    readonly vaultId: string | undefined;
+    constructor(message: string, vaultId?: string, details?: Record<string, unknown>);
+}
+/**
+ * Strategy-related errors
+ */
+declare class StrategyError extends PyxisError {
+    readonly strategyId: string | undefined;
+    constructor(message: string, strategyId?: string, details?: Record<string, unknown>);
+}
+/**
+ * Rate limiting errors
+ */
+declare class RateLimitError extends PyxisError {
+    readonly retryAfter: number | undefined;
+    constructor(message: string, retryAfter?: number);
+}
+/**
+ * Configuration errors
+ */
+declare class ConfigError extends PyxisError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Error codes enum for easy reference
+ */
+declare enum ErrorCodes {
+    NETWORK_ERROR = "NETWORK_ERROR",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    WALLET_ERROR = "WALLET_ERROR",
+    CONTRACT_ERROR = "CONTRACT_ERROR",
+    TRANSACTION_ERROR = "TRANSACTION_ERROR",
+    VAULT_ERROR = "VAULT_ERROR",
+    STRATEGY_ERROR = "STRATEGY_ERROR",
+    RATE_LIMIT_ERROR = "RATE_LIMIT_ERROR",
+    CONFIG_ERROR = "CONFIG_ERROR"
+}
+/**
+ * Utility function to create appropriate error instances
+ */
+declare function createError(type: keyof typeof ErrorCodes, message: string, details?: Record<string, unknown>): PyxisError;
+
+/**
+ * Base adapter interface for chain-specific implementations
+ */
+
+interface TxParams {
+    /** Function name to call */
+    function: string;
+    /** Type arguments */
+    typeArguments?: string[];
+    /** Function arguments */
+    arguments?: any[];
+    /** To address (for EVM) */
+    to?: string;
+    /** Value (for EVM) */
+    value?: string;
+    /** ABI for encoding/decoding (optional) */
+    abi?: any;
+}
+interface ViewParams {
+    /** Function name to call */
+    function: string;
+    /** Type arguments */
+    typeArguments?: string[];
+    /** Function arguments */
+    arguments?: any[];
+    /** Contract address */
+    address?: string;
+    /** ABI for encoding/decoding (optional) */
+    abi?: any;
+}
+interface EventParams {
+    /** Contract address to filter events */
+    address?: string;
+    /** Event type to filter */
+    eventType?: string;
+    /** From block number */
+    fromBlock?: number;
+    /** To block number */
+    toBlock?: number;
+}
+interface QueryIndexerParams {
+    query: string;
+    variables?: {};
+}
+declare abstract class BaseChainAdapter<TClient> {
+    readonly chain: Chain;
+    protected client: TClient | null;
+    constructor(chain: Chain);
+    /**
+     * Create and initialize the blockchain client
+     */
+    abstract createClient(config?: any): TClient;
+    /**
+     * Get the current client
+     */
+    getClient(): TClient;
+    /**
+     * Get contract addresses from chain configuration
+     * @throws Error if contract addresses are not configured
+     */
+    getContractAddresses(): VaultContractAddressConfig;
+    /**
+     * Get a specific contract address
+     */
+    getContractAddress(contract: keyof VaultContractAddressConfig): string;
+    /**
+     * Build a transaction payload
+     */
+    abstract buildPayload(params: TxParams): Promise<TransactionPayload>;
+    /**
+     * Call a view function
+     */
+    abstract viewContract<T>(params: ViewParams): Promise<T>;
+    /**
+     * Subscribe to events
+     */
+    abstract subscribeToEvents(params: EventParams, callback: (event: any) => void): () => void;
+    /**
+     * Get transaction by hash
+     */
+    abstract getTransaction(hash: string): Promise<any>;
+    /**
+     * Get account balance
+     */
+    abstract getBalance(address: string, asset: string): Promise<string>;
+    /**
+     * Get current block number
+     */
+    abstract getBlockNumber(): Promise<number>;
+    /**
+     * Wait for transaction confirmation
+     */
+    abstract waitForTransaction(hash: string, maxWaitTime?: number): Promise<TransactionResult>;
+    /**
+     * Get the chain type
+     */
+    getChainType(): ChainType;
+    abstract queryIndexer<T extends {}>(params: QueryIndexerParams): Promise<T>;
+}
+
+/**
+ * Base interface for analytics client implementations
+ * Chain-specific analytics clients should implement this interface
+ */
+
+/**
+ * Base interface defining the analytics API contract
+ * All chain-specific analytics clients must implement this interface
+ */
+interface BaseAnalyticsClient {
+    /**
+     * Get vault activities with pagination
+     * @param args - Arguments for filtering and pagination
+     * @returns Promise with activities array and total count
+     */
+    getActivities(args: GetActivitiesArgs): Promise<{
+        activities: VaultActivity[];
+        total: number;
+    }>;
+    /**
+     * Get total value locked in base asset
+     * @param args - Vault and asset information
+     * @returns Promise with TVL as string
+     */
+    getTvlInBaseAsset(args: VaultTvlArgs): Promise<string>;
+    /**
+     * Get exchange rate update events within a time range
+     * @param args - Vault address and time range
+     * @returns Promise with array of exchange rate events
+     */
+    getUpdateExchangeRateEvents(args: HistoricalApyArgs): Promise<ExchangeRateEvent[]>;
+    /**
+     * Get 30-day APY for a vault
+     * @param vault - Vault address
+     * @returns Promise with APY as string percentage
+     */
+    get30DayApy(vault: string): Promise<string>;
+    /**
+     * Get historical APY data points
+     * @param args - Vault, time range, and optional window
+     * @returns Promise with array of APY data points
+     */
+    getHistoricalApy(args: HistoricalApyArgs): Promise<ApyDataPoint[]>;
+}
+
+/**
+ * Base API interfaces
+ */
+
+interface BaseAPI<TAdapter extends BaseChainAdapter<any> = BaseChainAdapter<any>> {
+    adapter: TAdapter;
+    chain: Chain;
+}
+
+interface CalculateWithdrawalAmountParams {
+    /** Amount of vault token, in raw amount */
+    offerAmount: bigint;
+    /** Price of vault token in quote safe, in raw amount */
+    price: bigint;
+    /** Slippage percentage in basis points (eg: 500 for 5%) */
+    slippage: bigint;
+    /** Offer decimals */
+    offerDecimals: number;
+}
+interface WithdrawRequest {
+    /** Amount of vault token, in raw amount */
+    offerAmount: bigint;
+    /** Price of vault token in quote safe, in raw amount */
+    price: bigint;
+    /** Minimum amount to receive in quote safe, in raw amount */
+    minimumReceive: bigint;
+}
+declare const calculateWithdrawalAmount: ({ offerAmount, price, slippage, offerDecimals, }: CalculateWithdrawalAmountParams) => WithdrawRequest;
+interface CalculateMinimumReceiveAmountParams {
+    /** Want amount in raw amount */
+    wantAmount: bigint;
+    /** Slippage percentage in basis points (eg: 500 for 5%) */
+    slippage: bigint;
+}
+declare const calculateMinimumReceiveAmount: ({ wantAmount, slippage, }: CalculateMinimumReceiveAmountParams) => bigint;
+
+declare function normalizeAddress(address: string): string;
+
+/**
+ * Calculate APY based on withdraw rate changes over time
+ * @param events - Array of APY events with withdraw/deposit rates and timestamps
+ * @returns APY percentage as a string with 2 decimal places
+ */
+declare const calculateApy: (firstEvent: ExchangeRateEvent, lastEvent: ExchangeRateEvent) => string;
+
+/**
+ * Constants for flag bit positions and values
+ */
+declare const FLAG_BITS: {
+    /** bit 0 (1): deadline passed */
+    readonly DEADLINE_PASSED: 1;
+    /** bit 1 (2): zero offer amount */
+    readonly ZERO_OFFER_AMOUNT: 2;
+    /** bit 2 (4): minimum age not met */
+    readonly MINIMUM_AGE_NOT_MET: 4;
+};
+/**
+ * Type for flag bit keys
+ */
+type FlagBitKey = keyof typeof FLAG_BITS;
+/**
+ * Parses a numeric flag value into a RequestFlagState object.
+ *
+ * @param flagNumber - The numeric flag value (e.g., 5)
+ * @returns RequestFlagState object with boolean properties for each flag
+ *
+ * @example
+ * parseRequestFlags(0)  // { deadlinePassed: false, zeroOfferAmount: false, minimumAgeNotMet: false }
+ * parseRequestFlags(5)  // { deadlinePassed: true, zeroOfferAmount: false, minimumAgeNotMet: true }
+ */
+declare const parseRequestFlags: (flagNumber: number) => PyxisRequestFlagState;
+/**
+ * Builds a numeric flag value from a partial RequestFlagState object.
+ *
+ * @param flags - Partial object with boolean flag properties
+ * @returns Numeric flag value representing the combined flags
+ *
+ * @example
+ * buildRequestFlags({})                    // 0
+ * buildRequestFlags({ deadlinePassed: true })  // 1
+ */
+declare const buildRequestFlags: (flags: Partial<PyxisRequestFlagState>) => number;
+/**
+ * Checks if a specific flag is set in the given flag number.
+ *
+ * @param flagNumber - The numeric flag value to check
+ * @param flagType - The specific flag type to check
+ * @returns true if the specified flag is set, false otherwise
+ *
+ * @example
+ * hasFlag(1, 'DEADLINE_PASSED')      // true
+ * hasFlag(2, 'ZERO_OFFER_AMOUNT')    // true
+ */
+declare const hasFlag: (flagNumber: number, flagType: FlagBitKey) => boolean;
+/**
+ * Gets an array of all active flag names for a given flag number.
+ *
+ * @param flagNumber - The numeric flag value to analyze
+ * @returns Array of flag type names that are currently set
+ *
+ * @example
+ * getActiveFlags(0)  // []
+ * getActiveFlags(1)  // ['DEADLINE_PASSED']
+ * getActiveFlags(5)  // ['DEADLINE_PASSED', 'MINIMUM_AGE_NOT_MET']
+ * getActiveFlags(7)  // ['DEADLINE_PASSED', 'ZERO_OFFER_AMOUNT', 'MINIMUM_AGE_NOT_MET']
+ */
+declare const getActiveFlags: (flagNumber: number) => FlagBitKey[];
+
+/**
+ * Maps an OnchainWithdrawalRequest to a WithdrawalRequest with camelCase properties
+ * @param onchainRequest The onchain withdrawal request with snake_case properties
+ * @param updatedAt Optional timestamp when the request was last updated
+ * @returns The withdrawal request with camelCase properties
+ */
+declare function mapOnchainToWithdrawalRequest(onchainRequest: PyxisOnchainWithdrawalRequest, updatedAt?: string): PyxisWithdrawalRequest;
+/**
+ * Maps an IndexerVaultActivity to a VaultActivity with camelCase properties
+ * @param indexerActivity The indexer activity with snake_case properties
+ * @returns The vault activity with camelCase properties
+ */
+declare function mapIndexerToVaultActivity(indexerActivity: IndexerVaultActivity): VaultActivity;
+/**
+ * Maps an IndexerExchangeRateEvent to an ExchangeRateEvent with camelCase properties
+ * @param indexerEvent The indexer exchange rate event with snake_case properties
+ * @returns The exchange rate event with camelCase properties
+ */
+declare function mapIndexerToExchangeRateEvent(indexerEvent: IndexerExchangeRateEvent): ExchangeRateEvent;
+
+declare const amountWithSlippage: (rawAmount: bigint, slippageBips: bigint) => bigint;
+
+declare enum SamplingStrategy {
+    START = "start",// First event of the day
+    END = "end",// Last event of the day
+    MEDIAN = "median",// Middle event of the day
+    AVERAGE = "average"
+}
+/**
+ * Samples exchange rate events to get one event per day.
+ *
+ * @param events - Array of exchange rate events to sample
+ * @param strategy - Sampling strategy: 'start' (first event), 'end' (last event), 'median' (middle event), 'average' (averaged exchange rate)
+ * @returns Array of sampled events with one event per day, sorted by timestamp
+ */
+declare const sampleEventsByDay: (events: ExchangeRateEvent[], strategy?: SamplingStrategy) => ExchangeRateEvent[];
+
+declare const index_FLAG_BITS: typeof FLAG_BITS;
+type index_FlagBitKey = FlagBitKey;
+type index_SamplingStrategy = SamplingStrategy;
+declare const index_SamplingStrategy: typeof SamplingStrategy;
+declare const index_amountWithSlippage: typeof amountWithSlippage;
+declare const index_buildRequestFlags: typeof buildRequestFlags;
+declare const index_calculateApy: typeof calculateApy;
+declare const index_calculateMinimumReceiveAmount: typeof calculateMinimumReceiveAmount;
+declare const index_calculateWithdrawalAmount: typeof calculateWithdrawalAmount;
+declare const index_getActiveFlags: typeof getActiveFlags;
+declare const index_hasFlag: typeof hasFlag;
+declare const index_mapIndexerToExchangeRateEvent: typeof mapIndexerToExchangeRateEvent;
+declare const index_mapIndexerToVaultActivity: typeof mapIndexerToVaultActivity;
+declare const index_mapOnchainToWithdrawalRequest: typeof mapOnchainToWithdrawalRequest;
+declare const index_normalizeAddress: typeof normalizeAddress;
+declare const index_parseRequestFlags: typeof parseRequestFlags;
+declare const index_sampleEventsByDay: typeof sampleEventsByDay;
+declare namespace index {
+  export { index_FLAG_BITS as FLAG_BITS, type index_FlagBitKey as FlagBitKey, index_SamplingStrategy as SamplingStrategy, index_amountWithSlippage as amountWithSlippage, index_buildRequestFlags as buildRequestFlags, index_calculateApy as calculateApy, index_calculateMinimumReceiveAmount as calculateMinimumReceiveAmount, index_calculateWithdrawalAmount as calculateWithdrawalAmount, index_getActiveFlags as getActiveFlags, index_hasFlag as hasFlag, index_mapIndexerToExchangeRateEvent as mapIndexerToExchangeRateEvent, index_mapIndexerToVaultActivity as mapIndexerToVaultActivity, index_mapOnchainToWithdrawalRequest as mapOnchainToWithdrawalRequest, index_normalizeAddress as normalizeAddress, index_parseRequestFlags as parseRequestFlags, index_sampleEventsByDay as sampleEventsByDay };
+}
+
+export { type AnyTransaction, type AptosTransaction, type AptosTransactionPayload, type ApyDataPoint, type ApyWindow, type BaseAPI, type BaseAnalyticsClient, BaseChainAdapter, type BaseTransaction, type BuildCancelWithdrawalRequestTxArgs, type BuildDepositTxArgs, type BuildReclaimWithdrawalRequestTxArgs, type BuildWithdrawTxArgs, CHAIN_CONFIGS, type Chain, type ChainConfig, ChainId, ChainType, ConfigError, ContractError, type Currency, ErrorCodes, type EthereumJsonRpcRequest, type EthereumTransaction, type EventParams, type ExchangeRateEvent, type GetActivitiesArgs, type GetDepositRateInQuoteSafeArgs, type GetMinimumRequestAgeArgs, type GetWithdrawRateInQuoteSafeArgs, type GetWithdrawalRequestsOfUserArgs, type HistoricalApyArgs, type IndexerExchangeRateEvent, type IndexerVaultActivity, InsufficientFundsError, NetworkError, NetworkType, PyxisError, type PyxisOnchainWithdrawalRequest, type PyxisRequestFlagState, type PyxisToken, index as PyxisUtils, type PyxisWithdrawalRequest, type QueryIndexerParams, type QuoteDepositArgs, type QuoteWithdrawArgs, RateLimitError, type SDKConfig, type SignedTransaction, StrategyError, TransactionError, type TransactionPayload, type TransactionResult, type TxParams, ValidationError, type VaultActivity, type VaultContractAddressConfig, VaultError, type VaultTvlArgs, type ViewParams, type WalletAccount, type WalletAdapter, WalletError, createError, getChainConfig };