@gearbox-protocol/sdk 13.3.2 → 13.3.4

package/dist/types/sdk/base/TokensMeta.d.ts

@@ -3,21 +3,54 @@ import type { PhantomTokenContractType } from "../constants/index.js";
 import type { Asset } from "../router/index.js";
 import { AddressMap } from "../utils/index.js";
 import type { TokenMetaData } from "./types.js";
+/**
+ * Options for {@link TokensMeta.formatBN}.
+ **/
 export interface FormatBNOptions {
+    /**
+     * Number of decimal places in the formatted output.
+     **/
     precision?: number;
+    /**
+     * When `true`, appends the token symbol to the formatted string.
+     **/
     symbol?: boolean;
 }
+/**
+ * Token metadata enriched with some attributes specific to certain classes of tokens
+ **/
 export interface TokenMetaDataExtended extends TokenMetaData {
     /**
-     * Undefined if token is not a phantom token
-     */
+     * Classification of the phantom token, or `undefined` for normal tokens.
+     **/
     phantomTokenType?: PhantomTokenContractType;
 }
+/**
+ * Registry of token metadata (symbol, decimals, phantom type) keyed by address.
+ *
+ * Extends {@link AddressMap} with convenience accessors for formatting token
+ * amounts and looking up tokens by symbol.
+ *
+ * Provides methods to lazy-load information about certain classes of tokens (e.g. phantom tokens)
+ */
 export declare class TokensMeta extends AddressMap<TokenMetaDataExtended> {
     #private;
     constructor(client: PublicClient<Transport, Chain>);
+    /**
+     * Clears all token metadata
+     **/
     reset(): void;
+    /**
+     * Returns the symbol string for a token.
+     * @param token - Token address.
+     * @throws If the token is not in the registry.
+     */
     symbol(token: Address): string;
+    /**
+     * Returns the decimal count for a token.
+     * @param token - Token address.
+     * @throws If the token is not in the registry.
+     */
     decimals(token: Address): number;
     /**
      * Returns the phantom token type for a given token, or undefined for normal tokens
@@ -29,9 +62,33 @@ export declare class TokensMeta extends AddressMap<TokenMetaDataExtended> {
      * Throws if the phantom token data is not loaded
      */
     get phantomTokens(): AddressMap<TokenMetaDataExtended>;
+    /**
+     * Formats a raw token amount into a human-readable decimal string,
+     * dividing by `10^decimals` for the token.
+     *
+     * Accepts either an {@link Asset} object or a separate `(token, amount)` pair.
+     *
+     * @param asset - Asset object containing `token` address and `balance`.
+     * @param options - Formatting options.
+     */
     formatBN(asset: Asset, options?: FormatBNOptions): string;
+    /**
+     * @param token - Token address.
+     * @param amount - Raw amount (in smallest unit).
+     * @param options - Formatting options.
+     */
     formatBN(token: Address, amount: number | bigint | string | undefined, options?: FormatBNOptions): string;
+    /**
+     * Finds a token by its symbol (e.g. `"USDC"`).
+     * @param symbol - Case-sensitive ticker symbol.
+     * @returns The matching metadata, or `undefined` if no token has this symbol.
+     */
     findBySymbol(symbol: string): TokenMetaData | undefined;
+    /**
+     * Finds a token by its symbol, throwing if not found.
+     * @param symbol - Case-sensitive ticker symbol.
+     * @throws If no token matches the symbol.
+     */
     mustFindBySymbol(symbol: string): TokenMetaData;
     /**
      * Loads phantom token data for all known tokens from chain

package/dist/types/sdk/base/types.d.ts

@@ -5,65 +5,208 @@ import type { gaugeCompressorAbi } from "../../abi/compressors/gaugeCompressor.j
 import type { marketCompressorAbi } from "../../abi/compressors/marketCompressor.js";
 import type { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
 import type { rewardsCompressorAbi } from "../../abi/compressors/rewardsCompressor.js";
+/**
+ * Recursively unwraps array types to their element type.
+ **/
 export type Unarray<A> = A extends readonly unknown[] ? Unarray<A[number]> : A;
+/**
+ * On-chain identification parameters shared by all Gearbox contracts.
+ **/
 export interface BaseParams {
+    /**
+     * Contract address.
+     **/
     addr: Address;
+    /**
+     * Contract version as a raw `uint256`.
+     **/
     version: bigint;
+    /**
+     * ABI-encoded contract type identifier (bytes32).
+     **/
     contractType: Hex;
+    /**
+     * Opaque ABI-encoded configuration specific to the contract type.
+     **/
     serializedParams: Hex;
 }
+/**
+ * Same as {@link BaseParams} but accepts JS-friendly value types, useful when
+ * constructing parameters manually rather than reading them from chain.
+ */
 export interface RelaxedBaseParams {
+    /**
+     * Contract address.
+     **/
     addr: Address;
+    /**
+     * Contract version as a JS `number` or raw `bigint`.
+     **/
     version: number | bigint;
     /**
-     * Hex or parsed hex32 string
-     */
+     * Hex bytes32 or its human-readable parsed string.
+     **/
     contractType: string;
+    /**
+     * Optional ABI-encoded configuration.
+     **/
     serializedParams?: Hex;
 }
+/**
+ * Wrapper that pairs any contract state payload with its {@link BaseParams}.
+ **/
 export interface BaseState {
     baseParams: BaseParams;
 }
+/**
+ * Filter criteria for querying markets.
+ **/
 export type MarketFilter = AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof marketCompressorAbi, "getMarkets">["inputs"]>[0];
+/**
+ * Full on-chain snapshot of a single credit account.
+ **/
 export type CreditAccountData = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof creditAccountCompressorAbi, "getCreditAccountData">["outputs"]>>;
+/**
+ * Reward distribution details for a single reward token.
+ **/
 export type RewardInfo = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof rewardsCompressorAbi, "getRewards">["outputs"]>>;
+/**
+ * Full on-chain snapshot of a single Gearbox market (pool + credit managers + oracle).
+ **/
 export type MarketData = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof marketCompressorAbi, "getMarkets">["outputs"]>>;
+/**
+ * Gauge voting state for a pool.
+ **/
 export type GaugeData = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof gaugeCompressorAbi, "getGaugeInfo">["outputs"]>>;
+/**
+ * Bot connection data for a credit account.
+ **/
 export type ConnectedBotData = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof peripheryCompressorAbi, "getConnectedBots">["outputs"]>>;
+/**
+ * On-chain state of a single credit suite (credit manager + facade + configurator + adapters).
+ **/
 export type CreditSuiteState = Unarray<MarketData["creditManagers"]>;
+/**
+ * On-chain state of a credit manager contract.
+ **/
 export type CreditManagerState = CreditSuiteState["creditManager"];
+/**
+ * On-chain state of a credit facade contract.
+ **/
 export type CreditFacadeState = CreditSuiteState["creditFacade"];
+/**
+ * On-chain state of a credit configurator contract.
+ **/
 export type CreditConfiguratorState = CreditSuiteState["creditConfigurator"];
+/**
+ * Adapter contract data for a credit suite.
+ **/
 export type AdapterData = Unarray<CreditSuiteState["adapters"]>;
+/**
+ * On-chain metadata for a single token (symbol, decimals, address).
+ **/
 export type TokenMetaData = Unarray<MarketData["tokens"]>;
+/**
+ * On-chain state of a lending pool.
+ **/
 export type PoolState = MarketData["pool"];
+/**
+ * On-chain state of a quota keeper.
+ **/
 export type QuotaKeeperState = MarketData["quotaKeeper"];
+/**
+ * Quota parameters for a single token in a market.
+ **/
 export type QuotaState = Unarray<QuotaKeeperState["quotas"]>;
+/**
+ * On-chain state of a rate keeper.
+ **/
 export type RateKeeperState = MarketData["rateKeeper"];
+/**
+ * On-chain state of a price oracle (feed map + feed tree).
+ **/
 export type PriceOracleData = MarketData["priceOracle"];
+/**
+ * Single token-to-price-feed mapping entry in the oracle.
+ **/
 export type PriceFeedMapEntry = Unarray<PriceOracleData["priceFeedMap"]>;
+/**
+ * Node in the hierarchical price feed tree.
+ **/
 export type PriceFeedTreeNode = Unarray<PriceOracleData["priceFeedTree"]>;
+/**
+ * Latest price answer from a price feed.
+ **/
 export type PriceFeedAnswer = PriceFeedTreeNode["answer"];
+/**
+ * Debt parameters for a credit manager within a pool.
+ **/
 export type CreditManagerDebtParams = Unarray<PoolState["creditManagerDebtParams"]>;
+/**
+ * Whether a contract is permitted to participate in gauge voting.
+ **/
 export declare enum VotingContractStatus {
     NOT_ALLOWED = 0,
     ALLOWED = 1,
     UNVOTE_ONLY = 2
 }
+/**
+ * String-valued record of named function arguments produced by calldata parsing.
+ **/
 export type ParsedCallArgs = Record<string, string>;
+/**
+ * Human-readable representation of a decoded contract call (v1 format, string-coerced args).
+ **/
 export interface ParsedCall {
+    /**
+     * Chain the call targets.
+     **/
     chainId: number;
+    /**
+     * Address of the called contract.
+     **/
     target: Address;
+    /**
+     * Gearbox contract type identifier (e.g. `"CREDIT_MANAGER"`).
+     **/
     contractType: string;
+    /**
+     * Human-readable label for the target address.
+     **/
     label: string;
+    /**
+     * Decoded function name, or a placeholder for unknown selectors.
+     **/
     functionName: string;
+    /**
+     * Named arguments as string key-value pairs.
+     **/
     args: ParsedCallArgs;
 }
+/**
+ * Structured representation of a decoded contract call (v2 format) that
+ * preserves original argument types instead of coercing to strings.
+ */
 export interface ParsedCallV2 {
+    /**
+     * Chain the call targets.
+     **/
     chainId: number;
+    /**
+     * Address of the called contract.
+     **/
     target: Address;
+    /**
+     * Gearbox contract type identifier.
+     **/
     contractType: string;
+    /**
+     * Human-readable label for the target address.
+     **/
     label?: string;
+    /**
+     * Contract version number.
+     **/
     version: number;
     /**
      * Function signature produced by viem's `toFunctionSignature`, e.g.:
@@ -74,56 +217,73 @@ export interface ParsedCallV2 {
      * For unknown selectors: `"unknown function 0x1a2b3c4d"`
      */
     functionName: string;
+    /**
+     * Named arguments with their original types (bigint, Address, etc.).
+     **/
     rawArgs: Record<string, unknown>;
 }
+/**
+ * Shared interface for all SDK contract wrappers, providing identity fields
+ * and calldata decoding/stringifying capabilities.
+ */
 export interface IBaseContract {
     /**
-     * Contract address
+     * On-chain address of the contract.
      **/
     readonly address: Address;
     /**
-     * Contract type (parsed bytes32 or empty string)
+     * Human-readable contract type (e.g. `"CREDIT_MANAGER"`), or empty string if unknown.
      **/
     readonly contractType: string;
     /**
-     * Contract version
+     * Contract version number.
+     * @default 0
      **/
     readonly version: number;
     /**
-     * Internal name, for labeling purposes
-     * However, other contracts may add more labels, so prefer use labeling methods instead
-     **/
+     * Display name used for labeling in logs and parsed calls.
+     *
+     * @remarks Other contracts may register additional labels via
+     * {@link ChainContractsRegister.setAddressLabel}, so prefer the register's
+     * labeling methods for user-facing output.
+     */
     readonly name: string;
     /**
-     * Indicates that contract state diverged from onchain state and needs to be updated
-     */
+     * @internal
+     * `true` when the local state has diverged from on-chain and needs a sync.
+     **/
     dirty: boolean;
     /**
-     * Human-readable contract state
-     * @param raw
+     * Returns a human-readable snapshot of the contract's current state.
+     * @param raw - When `true`, includes raw/unformatted values.
      */
     stateHuman(raw?: boolean): unknown;
     /**
-     * Return parsed args and function name from calldata belonging to this contract
-     * Target of the call is always this contract, but args can be parsed into calls to other contracts (de-facto recursive ParsedCall)
-     **/
+     * Decodes calldata into a {@link ParsedCall} with string-coerced arguments.
+     *
+     * @remarks This is a safe method: unknown selectors produce a fallback
+     * result instead of throwing. For strict parsing, use {@link mustParseFunctionData}.
+     */
     parseFunctionData: (calldata: Hex) => ParsedCall;
     /**
-     * Same as {@link parseFunctionData}, but throws if error occurs
-     **/
+     * Same as {@link parseFunctionData}, but throws {@link ContractParseError}
+     * on unknown selectors.
+     */
     mustParseFunctionData: (calldata: Hex) => ParsedCall;
     /**
-     * Converts contract calldata to some human-friendly string
-     * This is safe function which should not throw
-     **/
+     * Converts calldata to a single human-friendly string (e.g. for logging).
+     *
+     * @remarks This is a safe method that never throws.
+     */
     stringifyFunctionData: (calldata: Hex) => string;
     /**
-     * Same as {@link stringifyFunctionData}, but throws if error occurs
-     **/
+     * Same as {@link stringifyFunctionData}, but throws on decode failure.
+     */
     mustStringifyFunctionData: (calldata: Hex) => string;
     /**
-     * Parses calldata into structured result with preserved original types.
-     * When strict is true, throws on unknown selectors; otherwise returns a fallback.
-     **/
+     * Decodes calldata into a {@link ParsedCallV2} preserving original argument types.
+     * @param calldata - Raw ABI-encoded calldata.
+     * @param strict - When `true`, throws on unknown selectors; otherwise returns a fallback.
+     */
     parseFunctionDataV2: (calldata: Hex, strict?: boolean) => ParsedCallV2;
 }

package/dist/types/sdk/chain/chains.d.ts

@@ -1,29 +1,55 @@
 import type { Address, Chain } from "viem";
 import { z } from "zod/v4";
+/**
+ * Known curator names that manage Gearbox markets.
+ *
+ **/
 export type Curator = "Chaos Labs" | "K3" | "cp0x" | "Re7" | "Invariant Group" | "Tulipa" | "M11 Credit" | "kpk" | "Hyperithm" | "UltraYield" | "TelosC" | "Gami Labs";
+/**
+ * Extended viem {@link Chain} with Gearbox-specific metadata.
+ *
+ * Every supported network is represented by a `GearboxChain` instance in
+ * the {@link chains} record.
+ **/
 export interface GearboxChain extends Chain {
+    /**
+     * Gearbox network type label (e.g. `"Mainnet"`, `"Arbitrum"`).
+     **/
     network: NetworkType;
+    /**
+     * Market configurator addresses operated by known curators on this chain.
+     **/
     defaultMarketConfigurators: Record<Address, Curator>;
+    /**
+     * Market configurators used in test/staging environments.
+     **/
     testMarketConfigurators?: Record<Address, Curator>;
+    /**
+     * Whether this chain is production-ready
+     **/
     isPublic: boolean;
     /**
-     * Pair of address and ERC-20 symbol of a well-known token on the chain
-     * This can be used to uniquely identify the chain from arbitrary RPC endpoint
+     * A well-known ERC-20 token that uniquely identifies this chain.
      *
-     * It must be guaranteed that under that address no contract that returns the same symbol is deployed on any other network
-     *
-     * @see {detectNetwork}
-     */
+     * Used by {@link detectNetwork} to determine which chain an arbitrary
+     * RPC endpoint is connected to.
+     **/
     wellKnownToken: {
         address: Address;
         symbol: string;
     };
     /**
-     * Block number when Gearbox address provider was deployed
-     */
+     * Block number when the Gearbox address provider was deployed.
+     **/
     firstBlock?: bigint;
 }
+/**
+ * Tuple of all network labels the SDK can work with.
+ **/
 export declare const SUPPORTED_NETWORKS: readonly ["Mainnet", "Arbitrum", "Optimism", "Base", "Sonic", "MegaETH", "Monad", "Berachain", "Avalanche", "BNB", "WorldChain", "Etherlink", "Hemi", "Lisk", "Plasma", "Somnia"];
+/**
+ * Zod schema for validating/parsing network type strings.
+ **/
 export declare const NetworkType: z.ZodEnum<{
     Mainnet: "Mainnet";
     Arbitrum: "Arbitrum";
@@ -42,23 +68,57 @@ export declare const NetworkType: z.ZodEnum<{
     Plasma: "Plasma";
     Somnia: "Somnia";
 }>;
+/**
+ * All supported Gearbox network labels
+ **/
 export type NetworkType = z.infer<typeof NetworkType>;
+/**
+ * Pre-configured {@link GearboxChain} instances for every supported network.
+ **/
 export declare const chains: Record<NetworkType, GearboxChain>;
+/**
+ * Returns the {@link GearboxChain} for a given chain ID or network type label.
+ *
+ * @param chainIdOrNetworkType - Numeric chain ID, bigint chain ID, or a {@link NetworkType} string.
+ * @throws If the chain ID / network type is not supported.
+ **/
 export declare function getChain(chainIdOrNetworkType: number | bigint | NetworkType): GearboxChain;
+/**
+ * Resolves a numeric chain ID to its {@link NetworkType} label.
+ *
+ * @param chainId - Numeric or bigint chain ID.
+ * @throws If the chain ID does not correspond to a supported network.
+ **/
 export declare function getNetworkType(chainId: number | bigint): NetworkType;
+/**
+ * Type guard that checks whether a chain ID belongs to a supported Gearbox network.
+ *
+ * @param chainId - Numeric chain ID, or `undefined`.
+ **/
 export declare function isSupportedNetwork(chainId: number | undefined): chainId is number;
+/**
+ * Returns `true` if the given network or chain ID has a publicly deployed Gearbox instance.
+ *
+ * @param networkOrChainId - {@link NetworkType} string or numeric chain ID.
+ **/
 export declare function isPublicNetwork(networkOrChainId: NetworkType | number | bigint): boolean;
 /**
- * Tries to find curator name by market configurator address among all default and test market configurators
- * @param marketConfigurator
- * @param network
- * @returns
- */
+ * Looks up the {@link Curator} name for a market configurator address.
+ *
+ * Searches default and test market configurators across all chains, or
+ * a single network if provided.
+ *
+ * @param marketConfigurator - On-chain market configurator address.
+ * @param network - Optional network to restrict the search to.
+ * @returns The curator name, or `undefined` if not found.
+ **/
 export declare function getCuratorName(marketConfigurator: Address, network?: NetworkType): Curator | undefined;
 /**
- * Finds market configurator address by curator name
- * @param curator
- * @param network
- * @returns
- */
+ * Finds the market configurator address for a given curator on a network.
+ *
+ * @param curator - Curator name to search for.
+ * @param network - Network to search in.
+ * @returns The market configurator address, or `undefined` if the curator
+ *   has no configurator on this network.
+ **/
 export declare function findCuratorMarketConfigurator(curator: Curator, network: NetworkType): Address | undefined;

package/dist/types/sdk/chain/detectNetwork.d.ts

@@ -1,3 +1,10 @@
 import type { PublicClient } from "viem";
 import type { NetworkType } from "./chains.js";
+/**
+ * Detects the network type from the given client.
+ * See {@link GearboxChain.wellKnownToken} for more details.
+ * @param client - viem public client
+ * @returns Network type
+ * @throws {Error} If the network type is not supported
+ */
 export declare function detectNetwork(client: PublicClient): Promise<NetworkType>;

package/dist/types/sdk/constants/address-provider.d.ts

@@ -1,5 +1,3 @@
-import type { Address } from "viem";
-import type { NetworkType } from "../chain/index.js";
 export declare const NO_VERSION = 0;
 export declare const AP_ACCOUNT_FACTORY = "ACCOUNT_FACTORY";
 export declare const AP_ACL = "ACL";
@@ -33,5 +31,8 @@ export declare const AP_WETH_GATEWAY = "WETH_GATEWAY";
 export declare const AP_WETH_TOKEN = "WETH_TOKEN";
 export declare const AP_ZAPPER_REGISTER = "ZAPPER_REGISTER";
 export declare const AP_ZERO_PRICE_FEED = "ZERO_PRICE_FEED";
-export declare const ADDRESS_PROVIDER: Record<NetworkType, Address>;
+/**
+ * Default address provider address for v3.1.0
+ * Is determenistic and does not depend on the network type
+ */
 export declare const ADDRESS_PROVIDER_V310 = "0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38";

package/dist/types/sdk/core/AbstractAddressProviderContract.d.ts

@@ -4,13 +4,36 @@ import { BaseContract, type ConstructOptions } from "../base/index.js";
 import type { VersionRange } from "../constants/index.js";
 import type { AddressProviderV3StateHuman } from "../types/index.js";
 import type { AddressProviderAddresses, AddressProviderState } from "./types.js";
+/**
+ * Base implementation of the Gearbox address provider contract.
+ *
+ * Maintains an in-memory registry of `(contractName, version) → address`
+ * mappings for all global (chain-wide) Gearbox contracts.
+ *
+ * @typeParam abi - The contract's ABI type.
+ **/
 export default abstract class AbstractAddressProviderContract<abi extends Abi | readonly unknown[]> extends BaseContract<abi> {
     #private;
     constructor(options: ConstructOptions, args: BaseContractArgs<abi>, addresses?: AddressProviderAddresses);
     protected setInternalAddress(key: string, address: Address, version: number): void;
+    /**
+     * {@inheritDoc IAddressProviderContract.getAddress}
+     **/
     getAddress(contract: string, version?: number): Address;
+    /**
+     * {@inheritDoc IAddressProviderContract.getLatest}
+     **/
     getLatest(contract: string, range: VersionRange): [address: Address, version: number] | undefined;
+    /**
+     * {@inheritDoc IAddressProviderContract.mustGetLatest}
+     **/
     mustGetLatest(contract: string, range: VersionRange): [address: Address, version: number];
+    /**
+     * {@inheritDoc IAddressProviderContract.state}
+     **/
     get state(): AddressProviderState;
+    /**
+     * {@inheritDoc IAddressProviderContract.stateHuman}
+     **/
     stateHuman(raw?: boolean): AddressProviderV3StateHuman;
 }

package/dist/types/sdk/core/types.d.ts

@@ -17,15 +17,61 @@ export interface AddressProviderAddresses {
      */
     overrides?: Record<string, Record<number, Address>>;
 }
+/**
+ * Serializable snapshot of the address provider's current state,
+ * including its on-chain identity and all registered contract addresses.
+ **/
 export interface AddressProviderState {
+    /**
+     * On-chain identification parameters for the address provider itself.
+     **/
     baseParams: BaseParams;
+    /**
+     * Registered addresses keyed by contract name, then by version number.
+     **/
     addresses: Record<string, Record<number, Address>>;
 }
+/**
+ * Public interface for the Gearbox address provider contract.
+ *
+ * The address provider is the single entry-point for discovering all other
+ * Gearbox contracts on a given chain. It maps `(contractName, version)` pairs
+ * to on-chain addresses.
+ **/
 export interface IAddressProviderContract extends IBaseContract {
+    /**
+     * Serializable snapshot of the provider's current state.
+     **/
     state: AddressProviderState;
+    /**
+     * Resolves the address of a registered contract by name and version.
+     * @param contract - Registered contract name (e.g. `"MARKET_COMPRESSOR"`).
+     * @param version - Version number to look up. Defaults to 0 - contract without versioning
+     * @throws If no address is registered for the given name and version.
+     **/
     getAddress: (contract: string, version?: number) => Address;
+    /**
+     * Finds the highest-versioned address within a version range.
+     * @param contract - Registered contract name.
+     * @param range - Inclusive `[min, max]` version range to search.
+     * @returns A `[address, version]` tuple, or `undefined` if none match.
+     **/
     getLatest: (contract: string, range: VersionRange) => [address: Address, version: number] | undefined;
+    /**
+     * Like {@link getLatest}, but throws if no address is found in the range.
+     * @param contract - Registered contract name.
+     * @param range - Inclusive `[min, max]` version range to search.
+     * @throws If no address is registered in the given range.
+     **/
     mustGetLatest: (contract: string, range: VersionRange) => [address: Address, version: number];
+    /**
+     * Re-reads all registered addresses from chain at the given block.
+     * @param blockNumber - Block number to read state at.
+     **/
     syncState: (blockNumber: bigint) => Promise<void>;
+    /**
+     * Returns a human-readable snapshot of the address provider state.
+     * @param raw - When `true`, includes raw/unformatted values alongside display strings.
+     **/
     stateHuman: (raw?: boolean) => AddressProviderV3StateHuman;
 }