@burnt-labs/account-management 0.0.1 → 1.0.0-alpha.2

package/dist/index.d.ts

@@ -0,0 +1,1308 @@
+import { AuthenticatorInfo, SmartAccount as SmartAccount$2, AuthenticatorType } from '@burnt-labs/signers';
+import { Coin } from 'cosmjs-types/cosmos/base/v1beta1/coin';
+import { DecodedReadableAuthorization, SignArbSecp256k1HdWallet, GranteeSignerClient, ConnectorConnectionResult, StorageStrategy, Connector } from '@burnt-labs/abstraxion-core';
+export { AuthorizationTypes, DecodedReadableAuthorization, HumanContractExecAuth } from '@burnt-labs/abstraxion-core';
+import { EncodeObject } from '@cosmjs/proto-signing';
+import { PeriodicAllowance, AllowedMsgAllowance } from 'cosmjs-types/cosmos/feegrant/v1beta1/feegrant';
+
+/**
+ * Account-management specific type extensions
+ * These extend the base types from @burnt-labs/signers with additional fields
+ * needed for account management operations
+ */
+
+/**
+ * Authenticator with required authenticatorIndex
+ * Extends base AuthenticatorInfo with required index field
+ */
+interface Authenticator extends Omit<AuthenticatorInfo, "authenticatorIndex"> {
+    authenticatorIndex: number;
+}
+/**
+ * Basic smart account (re-export base type)
+ */
+type SmartAccount$1 = SmartAccount$2;
+/**
+ * Smart account with required code ID
+ * Extends base SmartAccount with required codeId field
+ */
+interface SmartAccountWithCodeId extends Omit<SmartAccount$2, "codeId"> {
+    codeId: number;
+    authenticators: Authenticator[];
+}
+/**
+ * Smart account with current authenticator selection
+ * Used for operations that need to know which authenticator is active
+ */
+interface SelectedSmartAccount extends SmartAccountWithCodeId {
+    currentAuthenticatorIndex: number;
+}
+
+/**
+ * Checks if an authenticator already exists in the list
+ * @param authenticators - List of existing authenticators
+ * @param identifier - The authenticator identifier to check (e.g., "aud.sub" for JWT)
+ * @param type - The type of authenticator (e.g., "Jwt")
+ * @returns true if a duplicate exists, false otherwise
+ */
+declare function isDuplicateAuthenticator(authenticators: Authenticator[], identifier: string, type: string): boolean;
+/**
+ * Deduplicates accounts by their ID
+ * @param accounts - List of accounts that may contain duplicates
+ * @returns List of unique accounts
+ */
+declare function deduplicateAccountsById(accounts: SmartAccountWithCodeId[] | undefined): SmartAccountWithCodeId[];
+/**
+ * Finds the best matching authenticator from a list
+ * When multiple authenticators match, returns the one with the lowest index
+ * @param authenticators - List of authenticators to search
+ * @param loginAuthenticator - The authenticator identifier to match
+ * @returns The best matching authenticator or null if none found
+ */
+declare function findBestMatchingAuthenticator(authenticators: Authenticator[], loginAuthenticator: string): Authenticator | null;
+/**
+ * Validates if a new authenticator can be added
+ * @param authenticators - List of existing authenticators
+ * @param identifier - The new authenticator identifier
+ * @param type - The type of authenticator
+ * @returns Object with isValid flag and error message if invalid
+ */
+declare function validateNewAuthenticator(authenticators: Authenticator[], identifier: string, type: string): {
+    isValid: boolean;
+    errorMessage?: string;
+};
+
+/**
+ * Creates a JWT authenticator identifier from audience and subject
+ * @param aud - The audience claim from JWT
+ * @param sub - The subject claim from JWT
+ * @returns Formatted authenticator identifier
+ */
+declare function createJwtAuthenticatorIdentifier(aud: string | string[] | undefined, sub: string | undefined): string;
+
+/**
+ * Treasury parameters returned from treasury contract
+ * Matches the Params struct in contracts/contracts/treasury/src/state.rs
+ */
+interface TreasuryParams {
+    redirect_url: string;
+    icon_url: string;
+    metadata: string;
+}
+interface Any {
+    type_url: string;
+    value: string;
+}
+/**
+ * Grant configuration with additional fields for UI display
+ * Extended from TreasuryGrantConfig with extra fields like allowance for fee grants
+ */
+interface GrantConfigByTypeUrl {
+    authorization: Any;
+    description: string;
+    optional: boolean;
+    allowance?: Any;
+    maxDuration?: number;
+}
+/**
+ * Represents the complete treasury configuration including grant configs and parameters
+ */
+interface TreasuryConfig {
+    grantConfigs: GrantConfigByTypeUrl[];
+    params: TreasuryParams;
+}
+/**
+ * Strategy interface for fetching treasury configurations
+ * Different strategies can fetch from different sources (indexer, direct query, etc.)
+ */
+interface TreasuryStrategy {
+    /**
+     * Fetch treasury configuration for a given contract address
+     * @param treasuryAddress The treasury contract address
+     * @param client The Cosmos client for querying chain data (must have queryContractSmart method)
+     * @returns Treasury configuration or null if not found/failed
+     */
+    fetchTreasuryConfig(treasuryAddress: string, client: any): Promise<TreasuryConfig | null>;
+}
+
+/**
+ * Permission formatting utilities for treasury contracts
+ * Extracted from dashboard utils/query-treasury-contract.ts
+ */
+
+declare const DENOM_DECIMALS: {
+    readonly xion: 6;
+    readonly usdc: 6;
+};
+declare const DENOM_DISPLAY_MAP: {
+    readonly xion: "XION";
+    readonly usdc: "USDC";
+};
+/**
+ * Parses a coin string (e.g., "1000000uxion" or "1000000uxion,2000000usdc") into denom and amount
+ */
+declare function parseCoinString(coinStr: string): Coin[];
+/**
+ * Formats an array of Coin objects into a comma-separated string
+ */
+declare function formatCoinArray(coins: Coin[]): string;
+/**
+ * Formats a coin string (e.g. "1000000uxion") into a human readable format (e.g. "1 XION")
+ * Can handle multiple coins separated by commas
+ * @param coinStr The coin string to format
+ * @param usdcDenom Optional USDC denom to use for formatting (network-specific)
+ * @returns Formatted string of coins
+ */
+declare function formatCoins(coinStr: string, usdcDenom?: string): string;
+/**
+ * Formats a XION amount with its denom
+ */
+declare function formatXionAmount(amount: string, denom: string): string;
+/**
+ * Mapping of Cosmos message types to human-readable permission descriptions
+ */
+declare const CosmosAuthzPermission: {
+    [key: string]: string;
+};
+/**
+ * Permission description for display to users
+ */
+interface PermissionDescription {
+    authorizationDescription: string;
+    dappDescription?: string;
+    contracts?: (string | undefined)[];
+}
+/**
+ * Generate human-readable permission descriptions from decoded grants
+ * @param decodedGrants Array of decoded authorizations with dapp descriptions
+ * @param account User's account address (to validate contract grants)
+ * @param usdcDenom Optional USDC denom for formatting (network-specific)
+ * @returns Array of permission descriptions
+ */
+declare function generatePermissionDescriptions(decodedGrants: (DecodedReadableAuthorization & {
+    dappDescription: string;
+})[], account: string, usdcDenom?: string): PermissionDescription[];
+
+/**
+ * Treasury discovery utilities
+ * Queries treasury contracts to discover and format permissions for display
+ * Similar pattern to accounts/discovery.ts
+ */
+
+/**
+ * Minimal interface for blockchain client with smart contract query capability
+ * This avoids circular dependency with @burnt-labs/signers
+ */
+interface ContractQueryClient {
+    queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<unknown>;
+    getChainId(): Promise<string>;
+}
+interface TreasuryContractResponse {
+    permissionDescriptions: PermissionDescription[];
+    params: {
+        redirect_url: string;
+        icon_url: string;
+        metadata: string;
+    };
+}
+/**
+ * Queries the DAPP treasury contract to parse and display requested permissions to end user
+ * @param contractAddress - The address for the deployed treasury contract instance
+ * @param client - Client to query RPC (must have queryContractSmart method)
+ * @param account - Users account address
+ * @param strategy - Treasury strategy to use for querying
+ * @param usdcDenom - Optional USDC denom for formatting (network-specific)
+ * @returns The human-readable permission descriptions and treasury parameters
+ */
+declare function queryTreasuryContractWithPermissions(contractAddress: string, client: ContractQueryClient, account: string, strategy: TreasuryStrategy, usdcDenom?: string): Promise<TreasuryContractResponse>;
+
+type SpendLimit = {
+    denom: string;
+    amount: string;
+};
+type ContractGrantDescription = string | {
+    address: string;
+    amounts: SpendLimit[];
+};
+interface BaseAllowance {
+    "@type": string;
+}
+interface ContractsAllowance extends BaseAllowance {
+    "@type": "/xion.v1.ContractsAllowance";
+    allowance: PeriodicAllowance | BaseAllowance;
+    contractAddresses: string[];
+}
+interface MultiAnyAllowance extends BaseAllowance {
+    "@type": "/xion.v1.MultiAnyAllowance";
+    allowances: (ContractsAllowance | AllowedMsgAllowance | BaseAllowance)[];
+}
+type Allowance = PeriodicAllowance | AllowedMsgAllowance | ContractsAllowance | MultiAnyAllowance | BaseAllowance;
+interface AllowanceResponse {
+    allowance: {
+        granter: string;
+        grantee: string;
+        allowance: Allowance;
+    };
+}
+/**
+ * Grant creation configuration
+ * Used for configuring authorization grants from smart account to session keypair
+ */
+interface GrantConfig {
+    /** Treasury contract address (if using treasury-based grants) */
+    treasury?: string;
+    /** Manual contract grant descriptions */
+    contracts?: Array<string | {
+        address: string;
+        amounts: Array<{
+            denom: string;
+            amount: string;
+        }>;
+    }>;
+    /** Bank spend limits */
+    bank?: Array<{
+        denom: string;
+        amount: string;
+    }>;
+    /** Enable staking permissions */
+    stake?: boolean;
+    /** Fee granter address */
+    feeGranter?: string;
+    /** DaoDao indexer URL for treasury queries */
+    daodaoIndexerUrl?: string;
+}
+
+/**
+ * Grant message construction utilities
+ * Builds grant messages from treasury contracts or manual configurations
+ */
+
+/**
+ * Generate authz grant messages from treasury contract using strategy
+ *
+ * @param contractAddress - The address for the deployed treasury contract instance
+ * @param client - Client to query RPC (must have queryContractSmart method)
+ * @param granter - The granter address (smart account)
+ * @param grantee - The grantee address (temp keypair or user wallet)
+ * @param strategy - Treasury strategy to use for fetching configs
+ * @param expiration - Grant expiration timestamp (default: 3 months from now)
+ * @returns Array of authz grant messages to pass into transaction
+ */
+declare function generateTreasuryGrants(contractAddress: string, client: any, // AAClient from @burnt-labs/signers
+granter: string, grantee: string, strategy: TreasuryStrategy, expiration?: bigint): Promise<EncodeObject[]>;
+/**
+ * Generate bank (send) authorization grant
+ */
+declare function generateBankGrant(expiration: bigint, grantee: string, granter: string, bank: SpendLimit[]): EncodeObject;
+/**
+ * Generate contract execution authorization grant
+ */
+declare function generateContractGrant(expiration: bigint, grantee: string, granter: string, contracts: ContractGrantDescription[]): EncodeObject;
+/**
+ * Generate stake and governance authorization grants with fee grant
+ * Based on dashboard's generateStakeAndGovGrant
+ */
+declare function generateStakeAndGovGrant(expiration: bigint, grantee: string, granter: string): EncodeObject[];
+/**
+ * Build all grant messages based on user configuration
+ */
+declare function buildGrantMessages(params: {
+    granter: string;
+    grantee: string;
+    expiration: bigint;
+    contracts?: ContractGrantDescription[];
+    bank?: SpendLimit[];
+    stake?: boolean;
+}): EncodeObject[];
+
+/**
+ * Error for invalid contract grant configuration
+ */
+declare class InvalidContractGrantError extends Error {
+    constructor(message: string);
+}
+/**
+ * Checks if any of the contract grant configurations are the current smart account (granter)
+ * Address comparison is case-insensitive (bech32 addresses are case-insensitive in encoding).
+ *
+ * @param {ContractGrantDescription[]} contracts - An array of contract descriptions.
+ * @param {SelectedSmartAccount} account - The selected smart account (granter in this case)
+ * @returns {boolean} - Returns `true` if none of the contracts are the selected smart account, otherwise `false`.
+ * @throws {InvalidContractGrantError} - For malformed contract grant data
+ */
+declare const isContractGrantConfigValid: (contracts: ContractGrantDescription[], account: SelectedSmartAccount) => boolean;
+
+/**
+ * Error types for fee grant validation
+ */
+declare class FeeGrantValidationError extends Error {
+    readonly code: "NETWORK_ERROR" | "HTTP_ERROR" | "INVALID_RESPONSE" | "NO_ALLOWANCE" | "INVALID_ALLOWANCE";
+    readonly statusCode?: number | undefined;
+    constructor(message: string, code: "NETWORK_ERROR" | "HTTP_ERROR" | "INVALID_RESPONSE" | "NO_ALLOWANCE" | "INVALID_ALLOWANCE", statusCode?: number | undefined);
+}
+/**
+ * Result type for fee grant validation
+ */
+type FeeGrantValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: FeeGrantValidationError;
+};
+/**
+ * Validates if a requested set of actions are permitted under a fee grant between a granter and grantee.
+ *
+ * @async
+ * @function
+ * @param {string} restUrl - The base URL of the Cosmos REST API.
+ * @param {string} feeGranter - The address of the fee granter (the account providing the allowance).
+ * @param {string} granter - The address of the grantee (the account receiving the allowance).
+ * @param {string[]} requestedActions - The array of specific actions to validate, e.g., ["/cosmos.authz.v1beta1.MsgGrant", ...].
+ * @param {string} [userAddress] - (Optional) The user's smart contract account address to validate against `ContractsAllowance`.
+ * @returns {Promise<FeeGrantValidationResult>} - Result indicating if actions are permitted, with detailed error if not.
+ *
+ * @throws {FeeGrantValidationError} - For network errors, HTTP errors, or invalid responses.
+ */
+declare function validateFeeGrant(restUrl: string, feeGranter: string, granter: string, requestedActions: string[], userAddress?: string): Promise<FeeGrantValidationResult>;
+/**
+ * Error for invalid allowance structure
+ */
+declare class InvalidAllowanceError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates if requested actions are permitted by an allowance.
+ * Message type URLs are case-sensitive (protocol buffer type URLs).
+ *
+ * @param actions - Array of action type URLs to validate
+ * @param allowance - The allowance to check against
+ * @param userAddress - Optional user address for ContractsAllowance validation
+ * @returns true if all actions are permitted, false if actions are not permitted
+ * @throws {InvalidAllowanceError} - For malformed allowance structures
+ */
+declare function validateActions(actions: string[], allowance: Allowance, userAddress?: string): boolean;
+
+/**
+ * Contract address validation utilities
+ * Uses @burnt-labs/signers crypto utilities for consistent address validation
+ */
+
+interface AddressValidationError {
+    index: number;
+    address: string;
+    error: string;
+}
+interface ContractValidationResult {
+    valid: boolean;
+    errors: AddressValidationError[];
+}
+/**
+ * Extracts address from contract grant description
+ *
+ * @returns The contract address, or undefined if missing (for object form without address)
+ */
+declare function getContractAddress(contract: ContractGrantDescription): string | undefined;
+/**
+ * Checks if a contract address is self-referential (same as granter address)
+ * Uses case-insensitive comparison for bech32 addresses
+ *
+ * @param contractAddress - The contract address to check
+ * @param granterAddress - The granter address (smart account)
+ * @returns true if addresses match (self-referential), false otherwise
+ */
+declare function isSelfReferentialGrant(contractAddress: string, granterAddress: string): boolean;
+/**
+ * Validates a single contract address format
+ *
+ * @param address - Contract address to validate
+ * @param expectedPrefix - Expected bech32 prefix (e.g., "xion")
+ * @returns Error message if invalid, undefined if valid
+ */
+declare function validateContractAddressFormat(address: string, expectedPrefix: string): string | undefined;
+/**
+ * Verifies a contract exists on-chain
+ *
+ * @param address - Contract address to verify
+ * @param rpcUrl - RPC URL for chain queries
+ * @returns Error message if contract doesn't exist, undefined if valid
+ */
+declare function verifyContractExists(address: string, rpcUrl: string): Promise<string | undefined>;
+/**
+ * Validates array of contract grant descriptions
+ *
+ * Performs the following validations:
+ * 1. Bech32 format and prefix validation
+ * 2. Contract address != granter address
+ * 3. Contract exists on-chain (if rpcUrl provided)
+ *
+ * @param contracts - Array of contract grant descriptions
+ * @param granterAddress - The granter address (smart account)
+ * @param options - Validation options
+ * @returns Validation result with all errors
+ */
+declare function validateContractGrants(contracts: ContractGrantDescription[], granterAddress: string, options: {
+    expectedPrefix: string;
+    rpcUrl?: string;
+    skipOnChainVerification?: boolean;
+}): Promise<ContractValidationResult>;
+/**
+ * Formats validation errors into a human-readable message
+ *
+ * @param errors - Array of validation errors
+ * @returns Formatted error message
+ */
+declare function formatValidationErrors(errors: AddressValidationError[]): string;
+/**
+ * Validates contracts and throws with formatted error message if invalid
+ *
+ * Convenience function for use in grant creation flow.
+ *
+ * @throws {Error} If validation fails
+ */
+declare function validateContractGrantsOrThrow(contracts: ContractGrantDescription[], granterAddress: string, options: {
+    expectedPrefix: string;
+    rpcUrl?: string;
+    skipOnChainVerification?: boolean;
+}): Promise<void>;
+
+/**
+ * DaoDao Treasury Indexer Strategy
+ * Fetches treasury configurations from the DaoDao indexer API
+ * This is the fastest approach when the indexer is available
+ *
+ * How it works:
+ * 1. Queries DaoDao indexer API at /{chainId}/contract/{address}/xion/treasury/all
+ * 2. Transforms indexer response to standard TreasuryConfig format
+ * 3. Validates all data for security (URLs, structure)
+ *
+ * Based on dashboard's src/treasury-strategies/daodao-treasury-strategy.ts
+ */
+
+interface DaoDaoTreasuryStrategyConfig {
+    /** DaoDao indexer base URL (e.g., "https://daodaoindexer.burnt.com") */
+    indexerUrl: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * DaoDao Treasury Indexer Strategy
+ * Queries DaoDao indexer API for treasury configurations (fast, requires indexer)
+ *
+ */
+declare class DaoDaoTreasuryStrategy implements TreasuryStrategy {
+    private config;
+    constructor(config: DaoDaoTreasuryStrategyConfig);
+    fetchTreasuryConfig(treasuryAddress: string, client: ContractQueryClient): Promise<TreasuryConfig | null>;
+    /**
+     * Validates the /all endpoint response structure
+     */
+    private validateAllResponse;
+    /**
+     * Transform grant configs from /all response to standard format
+     */
+    private transformAllResponseGrants;
+}
+
+/**
+ * Direct Query Treasury Strategy
+ * Fetches treasury configurations directly from the smart contract via RPC
+ * This is the fallback approach when indexers are unavailable
+ *
+ * Based on dashboard's src/treasury-strategies/direct-query-treasury-strategy.ts
+ */
+
+/**
+ * Direct Query Treasury Strategy
+ * Queries treasury contract directly via RPC (no indexer needed)
+ */
+declare class DirectQueryTreasuryStrategy implements TreasuryStrategy {
+    fetchTreasuryConfig(treasuryAddress: string, client: ContractQueryClient): Promise<TreasuryConfig | null>;
+    /**
+     * Fetch treasury params directly from contract
+     */
+    private fetchTreasuryParams;
+}
+
+/**
+ * Composite Treasury Strategy
+ * Tries multiple strategies in order until one succeeds
+ * Implements the Strategy pattern with fallback behavior
+ *
+ * Based on dashboard's src/treasury-strategies/composite-treasury-strategy.ts
+ */
+
+/**
+ * Composite Treasury Strategy
+ * Tries multiple treasury strategies in order, returning the first successful result
+ *
+ */
+declare class CompositeTreasuryStrategy implements TreasuryStrategy {
+    private readonly strategies;
+    constructor(...strategies: TreasuryStrategy[]);
+    fetchTreasuryConfig(treasuryAddress: string, client: ContractQueryClient): Promise<TreasuryConfig | null>;
+}
+
+/**
+ * Factory function for creating a CompositeTreasuryStrategy with common fallback chain
+ * Provides a convenient way to create a treasury strategy without manually instantiating each one
+ */
+
+interface CreateCompositeTreasuryStrategyConfig {
+    /**
+     * DaoDao indexer configuration for fast treasury lookups
+     * If provided, DaoDaoTreasuryStrategy will be used as the first strategy
+     */
+    daodao?: {
+        indexerUrl: string;
+    };
+    /**
+     * Whether to include direct query strategy as fallback
+     * Defaults to true - recommended for production reliability
+     */
+    includeDirectQuery?: boolean;
+}
+/**
+ * Creates a CompositeTreasuryStrategy with automatic fallback chain:
+ * 1. DaoDaoTreasuryStrategy (if daodao config provided) - Fast indexer queries
+ * 2. DirectQueryTreasuryStrategy (if includeDirectQuery is true) - Reliable on-chain queries
+ *
+ * @param config - Configuration for the strategies to include
+ * @returns CompositeTreasuryStrategy with configured fallback chain
+ *
+ */
+declare function createCompositeTreasuryStrategy(config?: CreateCompositeTreasuryStrategyConfig): CompositeTreasuryStrategy;
+
+interface IndexerStrategy {
+    /**
+     * Fetch smart accounts for a given authenticator
+     *
+     * @param loginAuthenticator - The authenticator string (address, pubkey, JWT, etc.)
+     * @param authenticatorType - Authenticator type. Required because the type is always known from context
+     *                            (wallet connection, signer config, etc.) when checking for accounts.
+     */
+    fetchSmartAccounts(loginAuthenticator: string, authenticatorType: AuthenticatorType): Promise<SmartAccountWithCodeId[]>;
+}
+/**
+ * User-facing indexer configuration
+ * Used by developers when configuring account discovery
+ * For Subquery, codeId is derived from smartAccountContract, not provided by user
+ */
+type UserIndexerConfig = {
+    type?: "numia";
+    url: string;
+    authToken?: string;
+} | {
+    type: "subquery";
+    url: string;
+};
+/**
+ * Internal indexer configuration for account strategies
+ * Used internally by account discovery strategies
+ * For Subquery, codeId is required (derived from smartAccountContract during conversion)
+ */
+type AccountIndexerConfig = {
+    type?: "numia";
+    url: string;
+    authToken?: string;
+} | {
+    type: "subquery";
+    url: string;
+    codeId: number;
+};
+
+/**
+ * Numia indexer strategy for querying smart accounts
+ * Based on dashboard's src/indexer-strategies/numia-indexer-strategy.ts
+ */
+
+declare class NumiaAccountStrategy implements IndexerStrategy {
+    private readonly authToken?;
+    private baseURL;
+    constructor(baseURL: string, authToken?: string | undefined);
+    fetchSmartAccounts(loginAuthenticator: string, _authenticatorType: AuthenticatorType): Promise<SmartAccountWithCodeId[]>;
+}
+
+/**
+ * Subquery indexer strategy for querying smart accounts
+ * Based on dashboard's src/indexer-strategies/subquery-indexer-strategy.ts
+ *
+ * Subquery provides account addresses and authenticators but not code_id,
+ * so code_id must be configured (same pattern as RPC and Numia strategies)
+ */
+
+interface SmartAccountAuthenticator {
+    id: string;
+    type: string;
+    authenticator: string;
+    authenticatorIndex: number;
+    version: string;
+    __typename: string;
+}
+interface SmartAccountAuthenticatorsConnection {
+    nodes: SmartAccountAuthenticator[];
+    __typename: string;
+}
+interface SmartAccount {
+    id: string;
+    authenticators: SmartAccountAuthenticatorsConnection;
+    __typename: string;
+}
+interface SmartAccountsConnection {
+    nodes: SmartAccount[];
+    __typename: string;
+}
+interface AllSmartWalletQueryResponse {
+    smartAccounts: SmartAccountsConnection;
+}
+declare class SubqueryAccountStrategy implements IndexerStrategy {
+    private readonly indexerUrl;
+    private readonly codeId;
+    constructor(indexerUrl: string, codeId: number);
+    fetchSmartAccounts(loginAuthenticator: string, _authenticatorType: AuthenticatorType): Promise<SmartAccountWithCodeId[]>;
+}
+
+/**
+ * Direct Chain Indexer Strategy
+ * Queries the chain directly to find existing smart accounts
+ * This is a fallback when indexers are unavailable
+ *
+ * How it works:
+ * 1. Calculate predicted instantiate2 address from authenticator (using crypto utilities)
+ * 2. Check if contract exists at that address via RPC
+ * 3. If exists, query contract state for authenticators
+ * 4. Return account info
+ */
+
+interface RpcAccountStrategyConfig {
+    /** RPC URL for querying the chain */
+    rpcUrl: string;
+    /** Contract checksum (hex) for instantiate2 calculation */
+    checksum: string;
+    /** Creator/fee granter address */
+    creator: string;
+    /** Address prefix (e.g., "xion") */
+    prefix: string;
+    /** Code ID of the smart account contract */
+    codeId: number;
+}
+/**
+ * Direct Chain Indexer Strategy
+ * Calculates predicted address and queries chain directly (no indexer needed)
+ *
+ * TODO / NOTE : This strategy might not work for more complex scenarios like
+ * meta accounts where the authenticator in question has been removed or added to other accounts.
+ *
+ * Only to be used as a backup, indexers are the preferred way to find accounts.
+ */
+declare class RpcAccountStrategy implements IndexerStrategy {
+    private config;
+    constructor(config: RpcAccountStrategyConfig);
+    fetchSmartAccounts(loginAuthenticator: string, authenticatorType: AuthenticatorType): Promise<SmartAccountWithCodeId[]>;
+    /**
+     * Query authenticators from smart account contract
+     *
+     * Contract query schema:
+     * 1. Get authenticator IDs: {"authenticator_i_ds":{}} → [0, 1, 2, ...]
+     * 2. Get specific authenticator: {"authenticator_by_i_d":{"id":0}} → base64-encoded authenticator data
+     *
+     * Returns empty array if contract doesn't exist or query fails
+     */
+    private queryAuthenticators;
+}
+
+/**
+ * Empty Indexer Strategy
+ * Returns an empty array, indicating no existing accounts found
+ * This is the fallback strategy when no indexer is available
+ *
+ * When this strategy is used, the system will create a new smart account
+ * instead of trying to find an existing one.
+ */
+
+/**
+ * Empty Indexer Strategy
+ * Always returns an empty array (no accounts found)
+ *
+ * Use this as a fallback when:
+ * - No indexer is configured
+ * - Indexer is unavailable
+ * - You want to force creation of a new account
+ */
+declare class EmptyAccountStrategy implements IndexerStrategy {
+    fetchSmartAccounts(_loginAuthenticator: string, _authenticatorType: AuthenticatorType): Promise<SmartAccountWithCodeId[]>;
+}
+
+/**
+ * Composite Indexer Strategy
+ * Tries multiple indexer strategies in order until one succeeds
+ * Implements the Strategy pattern with fallback behavior
+ */
+
+/**
+ * Composite Indexer Strategy
+ * Tries multiple indexer strategies in order, returning the first successful result
+ */
+declare class CompositeAccountStrategy implements IndexerStrategy {
+    private readonly strategies;
+    constructor(...strategies: IndexerStrategy[]);
+    fetchSmartAccounts(loginAuthenticator: string, authenticatorType: AuthenticatorType): Promise<SmartAccountWithCodeId[]>;
+}
+
+/**
+ * Factory function for creating a CompositeAccountStrategy with common fallback chain
+ * Provides a convenient way to create a strategy without manually instantiating each one
+ */
+
+interface CreateCompositeAccountStrategyConfig {
+    /**
+     * Indexer configuration for fast account lookups
+     * Supports both Numia and Subquery indexers
+     *
+     * For Numia: { type: 'numia', url: string, authToken?: string }
+     * For Subquery: { type: 'subquery', url: string, codeId: number }
+     *
+     * If type is not specified, defaults to Numia for backward compatibility
+     */
+    indexer?: AccountIndexerConfig;
+    /**
+     * RPC configuration for reliable on-chain account lookups
+     * If provided, RpcAccountStrategy will be used as a fallback
+     */
+    rpc?: RpcAccountStrategyConfig;
+}
+/**
+ * Creates a CompositeAccountStrategy with automatic fallback chain:
+ * 1. Indexer strategy (Numia or Subquery, if configured) - Fast indexer queries
+ * 2. RpcAccountStrategy (if RPC config provided) - Reliable on-chain queries
+ * 3. EmptyAccountStrategy (always included) - Returns empty for new accounts
+ *
+ * @param config - Configuration for the strategies to include
+ * @returns CompositeAccountStrategy with configured fallback chain
+ *
+ */
+declare function createCompositeAccountStrategy(config: CreateCompositeAccountStrategyConfig): CompositeAccountStrategy;
+
+/**
+ * Type definitions for account management
+ *
+ */
+
+/**
+ * Smart account contract configuration
+ * Required for creating new smart accounts in signer mode
+ */
+interface SmartAccountContractConfig {
+    /** Contract code ID for smart account creation */
+    codeId: number;
+    /** Contract checksum as hex string */
+    checksum: string;
+    /** Address prefix (e.g., "xion") */
+    addressPrefix: string;
+}
+/**
+ * Account creation configuration
+ * Required for creating new smart accounts when they don't exist
+ * Aligned with the grouped config structure used in signer mode
+ */
+interface AccountCreationConfig {
+    /** AA API URL for account creation */
+    aaApiUrl: string;
+    /** Smart account contract configuration */
+    smartAccountContract: SmartAccountContractConfig;
+    /** Fee granter address (creator) */
+    feeGranter: string;
+}
+
+/**
+ * Utilities for converting user-facing indexer configs to AccountIndexerConfig
+ *
+ * These utilities are generic and work with any user-facing indexer config type
+ * that matches the shape of the discriminated union (Numia or Subquery).
+ */
+
+/**
+ * Extract authentication token from indexer config
+ * Only available for Numia indexers
+ *
+ * @param indexerConfig - User-facing indexer configuration
+ * @returns Authentication token if Numia indexer, undefined otherwise
+ */
+declare function extractIndexerAuthToken(indexerConfig?: UserIndexerConfig): string | undefined;
+/**
+ * Convert user-facing indexer config to internal AccountIndexerConfig
+ * Handles type conversion and derives codeId from smartAccountContract for Subquery indexers
+ *
+ * @param indexerConfig - User-facing indexer configuration
+ * @param smartAccountContract - Smart account contract config (required for Subquery codeId)
+ * @returns AccountIndexerConfig for use with account strategies, or undefined if no indexer config
+ * @throws Error if Subquery indexer is used without codeId in smartAccountContract
+ */
+declare function convertIndexerConfig(indexerConfig: UserIndexerConfig | undefined, smartAccountContract?: SmartAccountContractConfig): AccountIndexerConfig | undefined;
+
+/**
+ * Account discovery utilities
+ * Functions for checking if smart accounts exist
+ */
+
+/**
+ * Result of account existence check
+ */
+interface AccountExistenceResult {
+    exists: boolean;
+    accounts: any[];
+    smartAccountAddress?: string;
+    codeId?: number;
+    authenticatorIndex?: number;
+    error?: string;
+}
+/**
+ * Check if account exists using the account strategy
+ * Returns account details if found
+ *
+ * @param accountStrategy - The account strategy to use for discovery
+ * @param authenticator - The authenticator string (address, pubkey, JWT, etc.)
+ * @param authenticatorType - Authenticator type. Required because the type is always known from context
+ *                            (wallet connection, signer config, etc.) when checking for accounts.
+ */
+declare function checkAccountExists(accountStrategy: CompositeAccountStrategy, authenticator: string, authenticatorType: AuthenticatorType): Promise<AccountExistenceResult>;
+
+/**
+ * Account state machine types
+ * Defines the lifecycle states for account connection and management
+ * Shared between @abstraxion and @abstraxion-react-native
+ */
+
+/**
+ * Account information when connected
+ */
+interface AccountInfo {
+    /** The session keypair (grantee) */
+    keypair: SignArbSecp256k1HdWallet;
+    /** The smart account address (granter) */
+    granterAddress: string;
+    /** The grantee address (session key address) */
+    granteeAddress: string;
+}
+/**
+ * Account state machine states
+ * Represents the lifecycle: idle → initializing → redirecting → connecting → configuring-permissions → connected
+ *
+ * Note: The 'configuring-permissions' status represents setting up session permissions/authorization,
+ * not creating the session key itself (which happens during connecting).
+ */
+type AccountState = {
+    status: "idle";
+} | {
+    status: "initializing";
+} | {
+    status: "redirecting";
+    dashboardUrl: string;
+} | {
+    status: "connecting";
+    connectorId?: string;
+} | {
+    status: "configuring-permissions";
+    smartAccountAddress: string;
+} | {
+    status: "connected";
+    account: AccountInfo;
+    signingClient: GranteeSignerClient;
+} | {
+    status: "error";
+    error: string;
+};
+/**
+ * State transition actions
+ */
+type AccountStateAction = {
+    type: "INITIALIZE";
+} | {
+    type: "START_REDIRECT";
+    dashboardUrl: string;
+} | {
+    type: "START_CONNECT";
+    connectorId?: string;
+} | {
+    type: "START_CONFIGURING_PERMISSIONS";
+    smartAccountAddress: string;
+} | {
+    type: "SET_CONNECTED";
+    account: AccountInfo;
+    signingClient: GranteeSignerClient;
+} | {
+    type: "SET_ERROR";
+    error: string;
+} | {
+    type: "RESET";
+};
+/**
+ * State transition guard functions
+ */
+declare const AccountStateGuards: {
+    /** Check if state is idle */
+    isIdle: (state: AccountState) => state is {
+        status: "idle";
+    };
+    /** Check if state is initializing */
+    isInitializing: (state: AccountState) => state is {
+        status: "initializing";
+    };
+    /** Check if state is redirecting */
+    isRedirecting: (state: AccountState) => state is {
+        status: "redirecting";
+        dashboardUrl: string;
+    };
+    /** Check if state is connecting */
+    isConnecting: (state: AccountState) => state is {
+        status: "connecting";
+        connectorId?: string;
+    };
+    /** Check if state is configuring permissions for the session */
+    isConfiguringPermissions: (state: AccountState) => state is {
+        status: "configuring-permissions";
+        smartAccountAddress: string;
+    };
+    /** Check if state is connected (ready to use) */
+    isConnected: (state: AccountState) => state is {
+        status: "connected";
+        account: AccountInfo;
+        signingClient: GranteeSignerClient;
+    };
+    /** Check if state is error */
+    isError: (state: AccountState) => state is {
+        status: "error";
+        error: string;
+    };
+};
+/**
+ * State reducer function
+ * Handles state transitions based on actions
+ */
+declare function accountStateReducer(state: AccountState, action: AccountStateAction): AccountState;
+/**
+ * Helper to check if a transition is valid
+ */
+declare function isValidTransition(from: AccountState, to: AccountStateAction["type"]): boolean;
+
+/**
+ * Types for connection orchestrator
+ */
+
+/**
+ * Session management interface
+ * Abstracts session keypair and granter storage/retrieval
+ */
+interface SessionManager {
+    /** Get stored session keypair */
+    getLocalKeypair(): Promise<SignArbSecp256k1HdWallet | undefined>;
+    /** Generate and store a new session keypair */
+    generateAndStoreTempAccount(): Promise<SignArbSecp256k1HdWallet>;
+    /** Get stored granter address */
+    getGranter(): Promise<string | undefined>;
+    /** Set granter address */
+    setGranter(granter: string): Promise<void>;
+    /** Verify grants exist on-chain (authenticate) */
+    authenticate(): Promise<void>;
+    /** Clean up session (logout) */
+    logout(): Promise<void>;
+    /** Redirect to dashboard (optional, for redirect flow) */
+    redirectToDashboard?(): Promise<void>;
+    /** Complete login after redirect callback (optional, for redirect flow)
+     * Returns { keypair, granter } when login completes successfully, or undefined when redirecting
+     */
+    completeLogin?(): Promise<{
+        keypair: SignArbSecp256k1HdWallet;
+        granter: string;
+    } | undefined>;
+    /** Get signing client (optional, for redirect flow) */
+    getSigner?(): Promise<GranteeSignerClient>;
+    /** Subscribe to auth state changes (optional, for redirect flow) */
+    subscribeToAuthStateChange?(callback: (isLoggedIn: boolean) => void): () => void;
+}
+/**
+ * Connection result
+ * Return type from orchestrator connection operations
+ */
+interface ConnectionResult {
+    /** Smart account address (granter) */
+    smartAccountAddress: string;
+    /** Connection info from connector */
+    connectionInfo: ConnectorConnectionResult;
+    /** Session keypair (grantee) */
+    sessionKeypair: SignArbSecp256k1HdWallet;
+    /** Grantee address */
+    granteeAddress: string;
+    /** Signing client (if grants were created) */
+    signingClient?: GranteeSignerClient;
+}
+/**
+ * Session restoration result
+ * Uses AccountInfo when restored successfully to avoid duplication
+ */
+type SessionRestorationResult = {
+    restored: false;
+    error?: string;
+} | ({
+    restored: true;
+} & AccountInfo & {
+    signingClient?: GranteeSignerClient;
+});
+/**
+ * Type guard to check if session restoration was successful
+ */
+declare function isSessionRestored(result: SessionRestorationResult): result is {
+    restored: true;
+} & AccountInfo & {
+    signingClient?: GranteeSignerClient;
+};
+/**
+ * Type guard to check if session restoration failed with an error
+ */
+declare function isSessionRestorationError(result: SessionRestorationResult): result is {
+    restored: false;
+    error: string;
+};
+/**
+ * Extract AccountInfo from a restored session result
+ * Throws if session was not restored
+ */
+declare function getAccountInfoFromRestored(result: SessionRestorationResult): AccountInfo;
+
+/**
+ * Session restoration logic
+ * Extracted from AbstraxionContext restoreDirectModeSession function
+ */
+
+/**
+ * Configuration for creating a signing client during session restoration
+ */
+interface SigningClientConfig {
+    rpcUrl: string;
+    gasPrice: string;
+    treasuryAddress?: string;
+}
+/**
+ * Restore an existing session if valid
+ * Checks for stored keypair and granter, then verifies grants on-chain
+ * Optionally creates a signing client if config is provided
+ *
+ * @param sessionManager - Session management interface
+ * @param signingClientConfig - Optional config for creating signing client
+ * @returns Session restoration result with `restored: false` if no valid session exists,
+ *          or `restored: true` with `keypair`, `granterAddress`, and optionally `signingClient` if session was restored successfully
+ */
+declare function restoreSession(sessionManager: SessionManager, signingClientConfig?: SigningClientConfig): Promise<SessionRestorationResult>;
+
+/**
+ * Redirect flow logic
+ * Handles OAuth redirect flow using AbstraxionAuth methods
+ */
+
+/**
+ * Initiate redirect flow
+ * Requires SessionManager with redirectToDashboard() method
+ *
+ * @param sessionManager - Session manager that supports redirect flow
+ * @param rpcUrl - RPC URL for fetching dashboard URL from network config
+ * @returns Dashboard URL for state dispatch
+ */
+declare function initiateRedirect(sessionManager: SessionManager, rpcUrl: string): Promise<{
+    dashboardUrl: string;
+}>;
+/**
+ * Complete redirect flow after callback
+ * Requires SessionManager with completeLogin() and getSigner() methods
+ */
+declare function completeRedirect(sessionManager: SessionManager): Promise<SessionRestorationResult>;
+
+/**
+ * Grant creation logic
+ * Handles creating authorization grants from smart account to session keypair
+ */
+
+/**
+ * Result of grant creation operation
+ */
+type GrantCreationResult = {
+    success: true;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Parameters for grant creation
+ */
+interface GrantCreationParams {
+    /** Smart account address (granter) */
+    smartAccountAddress: string;
+    /** Connection result from connector */
+    connectionResult: ConnectorConnectionResult;
+    /** Session key address (grantee) */
+    granteeAddress: string;
+    /** Grant configuration */
+    grantConfig: GrantConfig;
+    /** Storage strategy for accessing stored values */
+    storageStrategy: StorageStrategy;
+    /** RPC URL */
+    rpcUrl: string;
+    /** Gas price (e.g., "0.001uxion") */
+    gasPrice: string;
+}
+/**
+ * Check if grants exist in storage for a given smart account
+ * Uses StorageStrategy to support both web (localStorage) and React Native (AsyncStorage)
+ *
+ * @param smartAccountAddress - The smart account address to check
+ * @param storageStrategy - Storage strategy for accessing stored values
+ * @returns Object with grantsExist flag and stored values
+ */
+declare function checkStorageGrants(smartAccountAddress: string, storageStrategy: StorageStrategy): Promise<{
+    grantsExist: boolean;
+    storedGranter: string | null;
+    storedTempAccount: string | null;
+}>;
+/**
+ * Create grants for a connected account
+ * Extracted from useGrantsFlow hook
+ *
+ * @param params - Grant creation parameters
+ * @returns Result indicating success or failure. On success, grants are created/verified.
+ *          Signing client should be created by the caller using the session keypair.
+ */
+declare function createGrants(params: GrantCreationParams): Promise<GrantCreationResult>;
+
+/**
+ * Connection Flow Orchestrator
+ * Coordinates the complete connection flow by combining:
+ * - accountConnection.ts: Connector connection & account discovery/creation
+ * - grantCreation.ts: Authorization grant creation
+ * - sessionRestoration.ts: Session restoration logic
+ *
+ * This orchestrator unifies all connector flows: session restoration, grant creation, account discovery
+ * It delegates implementation to the separate flow modules while coordinating the overall sequence.
+ */
+
+/**
+ * Configuration for ConnectionOrchestrator
+ */
+interface ConnectionOrchestratorConfig {
+    /** Session manager for keypair and granter storage */
+    sessionManager: SessionManager;
+    /** Storage strategy for accessing stored values (web: localStorage, React Native: AsyncStorage) */
+    storageStrategy: StorageStrategy;
+    /** Account discovery strategy (CompositeAccountStrategy from @burnt-labs/account-management) */
+    accountStrategy?: CompositeAccountStrategy;
+    /** Grant configuration */
+    grantConfig?: GrantConfig;
+    /** Account creation configuration (required if accounts need to be created) */
+    accountCreationConfig?: AccountCreationConfig;
+    /** Chain ID */
+    chainId: string;
+    /** RPC URL */
+    rpcUrl: string;
+    /** Gas price (e.g., "0.001uxion") */
+    gasPrice: string;
+}
+/**
+ * Connection Orchestrator
+ * Coordinates the full connection flow: connect → discover account → create grants → ready
+ */
+declare class ConnectionOrchestrator {
+    private config;
+    constructor(config: ConnectionOrchestratorConfig);
+    /**
+     * Restore an existing session if valid
+     * Checks for stored keypair and granter, then verifies grants on-chain
+     * Optionally creates a signing client if createSigningClient is true
+     *
+     * @param createSigningClient - If true, creates signing client for restored session
+     */
+    restoreSession(createSigningClient?: boolean): Promise<SessionRestorationResult>;
+    /**
+     * Check if grants exist in storage for a given smart account
+     * Uses StorageStrategy to support both web and React Native
+     */
+    checkStorageGrants(smartAccountAddress: string): Promise<{
+        grantsExist: boolean;
+        storedGranter: string | null;
+        storedTempAccount: string | null;
+    }>;
+    /**
+     * Connect via a connector and discover/create smart account
+     *
+     * @param connector - The connector to use
+     * @param authenticator - Optional authenticator string (if already known)
+     * @returns Connection result with smart account address and connection info
+     */
+    connect(connector: Connector, authenticator?: string): Promise<ConnectionResult>;
+    /**
+     * Create grants for a connected account
+     *
+     * @param smartAccountAddress - Smart account address (granter)
+     * @param connectionResult - Connection result from connector
+     * @param granteeAddress - Session key address (grantee)
+     * @returns Result indicating success or failure
+     */
+    createGrants(smartAccountAddress: string, connectionResult: ConnectorConnectionResult, granteeAddress: string): Promise<GrantCreationResult>;
+    /**
+     * Complete connection flow: connect → discover → create grants → ready
+     */
+    connectAndSetup(connector: Connector, authenticator?: string): Promise<ConnectionResult>;
+    /**
+     * Initiate redirect flow
+     * Uses AbstraxionAuth.redirectToDashboard() if available
+     *
+     * @returns Dashboard URL for state dispatch
+     */
+    initiateRedirect(): Promise<{
+        dashboardUrl: string;
+    }>;
+    /**
+     * Complete redirect flow after callback
+     * Uses AbstraxionAuth.login() if available
+     */
+    completeRedirect(): Promise<SessionRestorationResult>;
+    /**
+     * Create signing client for grantee using session keypair
+     * Used when grants already exist or after grants are created
+     */
+    private createSigningClient;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+
+/**
+ * Account connection logic
+ * Handles connecting via connector and discovering/creating smart accounts
+ */
+
+/**
+ * Parameters for account connection
+ */
+interface AccountConnectionParams {
+    /** The connector to use */
+    connector: Connector;
+    /** Optional authenticator string (if already known) */
+    authenticator?: string;
+    /** Chain ID */
+    chainId: string;
+    /** RPC URL for transaction confirmation */
+    rpcUrl: string;
+    /** Account discovery strategy */
+    accountStrategy: CompositeAccountStrategy;
+    /** Account creation configuration (required if accounts need to be created) */
+    accountCreationConfig?: AccountCreationConfig;
+    /** Session manager for keypair management */
+    sessionManager: SessionManager;
+}
+/**
+ * Connect via a connector and discover/create smart account
+ *
+ * @param params - Connection parameters
+ * @returns Connection result with smart account address and connection info
+ */
+declare function connectAccount(params: AccountConnectionParams): Promise<ConnectionResult>;
+
+export { AccountConnectionParams, AccountCreationConfig, AccountExistenceResult, AccountIndexerConfig, AccountInfo, AccountState, AccountStateAction, AccountStateGuards, AddressValidationError, AllSmartWalletQueryResponse, Allowance, AllowanceResponse, Authenticator, BaseAllowance, CompositeAccountStrategy, CompositeTreasuryStrategy, ConnectionOrchestrator, ConnectionOrchestratorConfig, ConnectionResult, ContractGrantDescription, ContractValidationResult, ContractsAllowance, CosmosAuthzPermission, CreateCompositeAccountStrategyConfig, CreateCompositeTreasuryStrategyConfig, DENOM_DECIMALS, DENOM_DISPLAY_MAP, DaoDaoTreasuryStrategy, DaoDaoTreasuryStrategyConfig, DirectQueryTreasuryStrategy, EmptyAccountStrategy, FeeGrantValidationError, FeeGrantValidationResult, GrantConfig, GrantCreationParams, GrantCreationResult, IndexerStrategy, InvalidAllowanceError, InvalidContractGrantError, MultiAnyAllowance, NumiaAccountStrategy, PermissionDescription, RpcAccountStrategy, RpcAccountStrategyConfig, SelectedSmartAccount, SessionManager, SessionRestorationResult, SigningClientConfig, SmartAccount$1 as SmartAccount, SmartAccountContractConfig, SmartAccountWithCodeId, SpendLimit, SubqueryAccountStrategy, TreasuryContractResponse, UserIndexerConfig, accountStateReducer, buildGrantMessages, checkAccountExists, checkStorageGrants, completeRedirect, connectAccount, convertIndexerConfig, createCompositeAccountStrategy, createCompositeTreasuryStrategy, createGrants, createJwtAuthenticatorIdentifier, deduplicateAccountsById, extractIndexerAuthToken, findBestMatchingAuthenticator, formatCoinArray, formatCoins, formatValidationErrors, formatXionAmount, generateBankGrant, generateContractGrant, generatePermissionDescriptions, generateStakeAndGovGrant, generateTreasuryGrants, getAccountInfoFromRestored, getContractAddress, initiateRedirect, isContractGrantConfigValid, isDuplicateAuthenticator, isSelfReferentialGrant, isSessionRestorationError, isSessionRestored, isValidTransition, parseCoinString, queryTreasuryContractWithPermissions, restoreSession, validateActions, validateContractAddressFormat, validateContractGrants, validateContractGrantsOrThrow, validateFeeGrant, validateNewAuthenticator, verifyContractExists };