@smartagentkit/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,743 @@
+import { Address, Hex, Chain } from 'viem';
+import * as _rhinestone_module_sdk from '@rhinestone/module-sdk';
+import { Session, EnableSessionData } from '@rhinestone/module-sdk';
+export { ActionData, EnableSessionData, PolicyData, Session, SmartSessionMode } from '@rhinestone/module-sdk';
+
+/** BIP-39 mnemonic phrase with optional HD derivation index */
+interface MnemonicCredential {
+    mnemonic: string;
+    /** HD derivation index (default: 0) — derives m/44'/60'/0'/0/{index} */
+    addressIndex?: number;
+}
+/**
+ * A signer credential: either a raw private key (0x-prefixed hex)
+ * or a BIP-39 mnemonic phrase.
+ *
+ * @example
+ * // Private key
+ * const key: SignerKey = "0xac09...f2ff80";
+ *
+ * // Mnemonic (default account index 0)
+ * const key: SignerKey = { mnemonic: "test test test..." };
+ *
+ * // Mnemonic with specific derivation index
+ * const key: SignerKey = { mnemonic: "test test test...", addressIndex: 2 };
+ */
+type SignerKey = Hex | MnemonicCredential;
+interface SmartAgentKitConfig {
+    /** The chain to deploy on */
+    chain: Chain;
+    /** RPC URL for the chain */
+    rpcUrl: string;
+    /** Bundler URL (Pimlico, Alchemy, etc.) */
+    bundlerUrl: string;
+    /** Optional paymaster URL for gas sponsorship */
+    paymasterUrl?: string;
+    /** Deployed module contract addresses (required for wallet creation) */
+    moduleAddresses?: ModuleAddresses;
+}
+interface ModuleAddresses {
+    /** SpendingLimitHook contract address */
+    spendingLimitHook: Address;
+    /** AllowlistHook contract address */
+    allowlistHook: Address;
+    /** EmergencyPauseHook contract address */
+    emergencyPauseHook: Address;
+    /** AutomationExecutor contract address (optional, Sprint 3) */
+    automationExecutor?: Address;
+}
+interface AgentWallet {
+    /** The smart account address */
+    address: Address;
+    /** The owner address (human/multisig with override control) */
+    owner: Address;
+    /** Chain the wallet is deployed on */
+    chain: Chain;
+    /** Whether the wallet is deployed on-chain yet */
+    isDeployed: boolean;
+    /** Installed policy modules */
+    policies: InstalledPolicy[];
+    /** Active session keys */
+    sessions: ActiveSession[];
+}
+interface CreateWalletParams {
+    /** Owner address — retains override/recovery control */
+    owner: Address;
+    /** Private key of the owner for signing the deployment. Provide this OR ownerMnemonic. */
+    ownerPrivateKey?: Hex;
+    /** BIP-39 mnemonic phrase of the owner. Provide this OR ownerPrivateKey. */
+    ownerMnemonic?: string;
+    /** HD derivation index (default: 0). Only used with ownerMnemonic. */
+    addressIndex?: number;
+    /** Policy modules to install at deployment */
+    policies?: PolicyConfig[];
+    /** Or use a named preset */
+    preset?: PresetName;
+    /** Preset-specific initialization parameters */
+    presetParams?: Record<string, unknown>;
+    /** Optional CREATE2 salt for deterministic address */
+    salt?: bigint;
+}
+type PresetName = "defi-trader" | "treasury-agent" | "payment-agent" | "minimal";
+type PolicyConfig = SpendingLimitPolicy | AllowlistPolicy | EmergencyPausePolicy | AutomationPolicy;
+interface SpendingLimitPolicy {
+    type: "spending-limit";
+    limits: TokenLimit[];
+}
+interface TokenLimit {
+    /** Token address (use "0x0000...0000" for native ETH) */
+    token: Address;
+    /** Maximum amount per window (in token's smallest unit, e.g., wei) */
+    limit: bigint;
+    /** Window duration in seconds */
+    window: number;
+}
+interface AllowlistPolicy {
+    type: "allowlist";
+    mode: "allow" | "block";
+    targets: TargetPermission[];
+    /** Infrastructure addresses blocked from being called as targets (hooks, multiplexer, executor) */
+    protectedAddresses?: Address[];
+}
+interface TargetPermission {
+    /** Contract address to allow/block */
+    address: Address;
+    /** Function selector (e.g., "0xa9059cbb" for transfer). Omit for wildcard (all functions).
+     *  NOTE: "0x00000000" is NOT a wildcard — it matches empty calldata (ETH transfers only).
+     *  The actual wildcard selector is 0x431e2cf5 (bytes4(keccak256("WILDCARD"))). */
+    selector?: Hex;
+}
+interface EmergencyPausePolicy {
+    type: "emergency-pause";
+    /** Address authorized to pause/unpause (typically the owner) */
+    guardian: Address;
+    /** Auto-unpause after this many seconds (0 = manual only) */
+    autoUnpauseAfter?: number;
+}
+interface AutomationPolicy {
+    type: "automation";
+    tasks: AutomationTask[];
+}
+interface AutomationTask {
+    id: string;
+    /** Address of the automation service (e.g., Gelato relay) */
+    caller: Address;
+    /** Target contract to call */
+    target: Address;
+    /** ETH value to send */
+    value?: bigint;
+    /** Calldata for the target function */
+    calldata: Hex;
+    /** Minimum seconds between executions */
+    cooldown: number;
+    /** Maximum number of executions (0 = unlimited) */
+    maxExecutions?: number;
+}
+interface CreateSessionParams {
+    /** The session key address (generated or provided) */
+    sessionKey: Address;
+    /** Allowed actions for this session */
+    actions: SessionAction[];
+    /** Expiry timestamp (Unix seconds) */
+    expiresAt: number;
+    /** Optional: spending limits specific to this session */
+    spendingLimits?: TokenLimit[];
+}
+interface SessionAction {
+    /** Target contract address */
+    target: Address;
+    /** Allowed function selector */
+    selector: Hex;
+    /** Optional: parameter-level restrictions */
+    rules?: SessionRule[];
+}
+interface SessionRule {
+    /** Byte offset in calldata to check */
+    offset: bigint;
+    /** Comparison condition */
+    condition: "equal" | "greater" | "less" | "notEqual";
+    /** Reference value to compare against */
+    value: Hex;
+}
+interface ActiveSession {
+    sessionKey: Address;
+    actions: SessionAction[];
+    expiresAt: number;
+    isActive: boolean;
+}
+interface ExecuteParams {
+    /** Target contract address */
+    target: Address;
+    /** ETH value to send */
+    value?: bigint;
+    /** Calldata for the function call */
+    data?: Hex;
+    /** Session key private key to sign with (if using session-based execution) */
+    sessionKey?: Hex;
+}
+interface ExecuteBatchParams {
+    calls: ExecuteParams[];
+    sessionKey?: Hex;
+}
+interface InstalledPolicy {
+    moduleAddress: Address;
+    moduleType: number;
+    name: string;
+    config: PolicyConfig;
+}
+/**
+ * Shared interface for SmartAgentKit clients.
+ * Both the real SmartAgentKitClient and MockSmartAgentKitClient implement this.
+ */
+interface ISmartAgentKitClient {
+    createWallet(params: CreateWalletParams): Promise<AgentWallet>;
+    connectWallet(walletAddress: Address, ownerKey: SignerKey): Promise<void>;
+    execute(wallet: AgentWallet, params: ExecuteParams): Promise<Hex>;
+    executeBatch(wallet: AgentWallet, params: ExecuteBatchParams): Promise<Hex>;
+    getRemainingAllowance(walletAddress: Address, token: Address): Promise<bigint>;
+    isPaused(walletAddress: Address): Promise<boolean>;
+    getBalances(walletAddress: Address): Promise<{
+        eth: bigint;
+        tokens: {
+            address: Address;
+            symbol: string;
+            balance: bigint;
+        }[];
+    }>;
+    pause(walletAddress: Address, guardianKey: SignerKey): Promise<Hex>;
+    unpause(walletAddress: Address, guardianKey: SignerKey): Promise<Hex>;
+    createSession(wallet: AgentWallet, params: CreateSessionParams, ownerKey: SignerKey): Promise<{
+        sessionKey: Address;
+        privateKey: Hex;
+        permissionId: Hex;
+    }>;
+    revokeSession(wallet: AgentWallet, permissionId: Hex, ownerKey: SignerKey): Promise<void>;
+    getActiveSessions(walletAddress: Address): ActiveSession[];
+}
+
+declare class SmartAgentKitClient implements ISmartAgentKitClient {
+    private config;
+    private publicClient;
+    private walletClients;
+    private sessions;
+    constructor(config: SmartAgentKitConfig);
+    /**
+     * Deploy a new policy-governed smart wallet for an AI agent.
+     *
+     * The wallet is a Safe smart account with ERC-7579 modules. A
+     * HookMultiPlexer is installed as the single hook, and sub-hooks
+     * (SpendingLimit, Allowlist, EmergencyPause) are routed through it.
+     *
+     * The deployment and policy initialization happen atomically in
+     * the first UserOperation.
+     */
+    createWallet(params: CreateWalletParams): Promise<AgentWallet>;
+    /**
+     * Reconnect to an existing wallet for executing transactions.
+     * Accepts a private key or mnemonic credential.
+     */
+    connectWallet(walletAddress: Address, ownerKey: SignerKey): Promise<void>;
+    predictAddress(_owner: Address, _salt?: bigint): Promise<Address>;
+    addPolicy(_wallet: AgentWallet, _policy: PolicyConfig, _ownerPrivateKey: Hex): Promise<void>;
+    removePolicy(_wallet: AgentWallet, _moduleAddress: Address, _ownerPrivateKey: Hex): Promise<void>;
+    getPolicies(_walletAddress: Address): Promise<InstalledPolicy[]>;
+    /**
+     * Create a session key for an AI agent.
+     *
+     * Generates a new ECDSA key pair and enables it as a session key on
+     * the smart account via Smart Sessions. The session is scoped to
+     * specific target contracts, function selectors, and time window.
+     *
+     * @returns The session key address, private key, and permission ID.
+     */
+    createSession(wallet: AgentWallet, params: CreateSessionParams, ownerKey: SignerKey): Promise<{
+        sessionKey: Address;
+        privateKey: Hex;
+        permissionId: Hex;
+    }>;
+    /**
+     * Revoke a session key, permanently disabling it.
+     */
+    revokeSession(wallet: AgentWallet, permissionId: Hex, _ownerKey: SignerKey): Promise<void>;
+    /**
+     * Get active sessions for a wallet.
+     */
+    getActiveSessions(walletAddress: Address): ActiveSession[];
+    /**
+     * Execute a single transaction from the agent wallet.
+     * The transaction is submitted as a UserOperation through the bundler.
+     * Hooks (spending limits, allowlist, pause) are enforced on-chain.
+     */
+    execute(wallet: AgentWallet, params: ExecuteParams): Promise<Hex>;
+    /**
+     * Execute a batch of transactions atomically from the agent wallet.
+     * All calls are encoded into a single UserOperation with batch mode.
+     */
+    executeBatch(wallet: AgentWallet, params: ExecuteBatchParams): Promise<Hex>;
+    /**
+     * Get the remaining spending allowance for a token on a wallet.
+     * Reads directly from the SpendingLimitHook contract.
+     */
+    getRemainingAllowance(walletAddress: Address, token: Address): Promise<bigint>;
+    /**
+     * Check if a wallet is currently paused.
+     * Reads directly from the EmergencyPauseHook contract.
+     */
+    isPaused(walletAddress: Address): Promise<boolean>;
+    /**
+     * Get the native ETH balance of a wallet.
+     */
+    getBalances(walletAddress: Address): Promise<{
+        eth: bigint;
+        tokens: {
+            address: Address;
+            symbol: string;
+            balance: bigint;
+        }[];
+    }>;
+    /**
+     * Pause a wallet. Must be called by the configured guardian.
+     * This is NOT a UserOp — it's a direct call to the EmergencyPauseHook.
+     */
+    pause(walletAddress: Address, guardianKey: SignerKey): Promise<Hex>;
+    /**
+     * Unpause a wallet. Must be called by the configured guardian.
+     */
+    unpause(walletAddress: Address, guardianKey: SignerKey): Promise<Hex>;
+    private resolvePolicies;
+    private requireModuleAddresses;
+    /**
+     * Build and send the first UserOp that initializes all sub-hooks
+     * and adds them to the HookMultiPlexer.
+     *
+     * This batch includes for each sub-hook:
+     * 1. onInstall(initData) — initialize the sub-hook for this account
+     * 2. setTrustedForwarder(hookMultiPlexer) — so sub-hooks resolve the
+     *    correct account when called through the multiplexer
+     * 3. addHook(hookAddress, GLOBAL) on HookMultiPlexer — register the
+     *    sub-hook for all transactions
+     */
+    private initializePolicies;
+    /**
+     * Push the 3 calls needed to initialize a sub-hook:
+     * 1. onInstall(initData) on the sub-hook
+     * 2. setTrustedForwarder(multiplexer) on the sub-hook
+     * 3. addHook(hookAddr, GLOBAL) on the HookMultiPlexer
+     */
+    private pushSubHookInitCalls;
+    private mapPoliciesToInstalled;
+    private getWalletClient;
+}
+
+/**
+ * Pre-built policy combinations for common agent types.
+ *
+ * Each preset returns an array of PolicyConfig objects that are
+ * installed on the wallet at deployment time.
+ */
+declare const PRESETS: Record<PresetName, (owner: Address, params?: Record<string, unknown>) => PolicyConfig[]>;
+
+interface EncodedPolicy {
+    moduleAddress: Address;
+    moduleType: number;
+    initData: Hex;
+}
+/**
+ * Encode a policy configuration into the format needed for module installation.
+ *
+ * The encoded data matches the Solidity `onInstall` decoder for each module:
+ *
+ * - **SpendingLimitHook:** `abi.encode(address trustedForwarder, TokenLimitInit[])` where each entry is
+ *   `(address token, uint256 limit, uint48 windowDuration)`
+ *
+ * - **AllowlistHook:** `abi.encode(address trustedForwarder, uint8 mode, TargetPermission[], address[] protectedAddresses)`
+ *   where each permission is `(address target, bytes4 selector)` and protectedAddresses are infrastructure contracts
+ *
+ * - **EmergencyPauseHook:** `abi.encode(address trustedForwarder, address guardian, uint48 autoUnpauseAfter)`
+ *
+ * @param policy - The policy configuration to encode.
+ * @param moduleAddresses - Optional map of module addresses per chain. If not
+ *        provided, module addresses will be set to zero (for SDK-level
+ *        configuration before deployment addresses are known).
+ * @param trustedForwarder - The HookMultiPlexer address to set as trusted forwarder.
+ *        Defaults to zero address (for direct usage without multiplexer).
+ * @returns The encoded policy with module address, type, and init data.
+ */
+declare function encodePolicyInitData(policy: PolicyConfig, moduleAddresses?: {
+    spendingLimitHook?: Address;
+    allowlistHook?: Address;
+    emergencyPauseHook?: Address;
+    automationExecutor?: Address;
+}, trustedForwarder?: Address): EncodedPolicy;
+/**
+ * Encode SpendingLimitHook init data.
+ *
+ * Solidity: `abi.decode(data, (address, TokenLimitInit[]))`
+ * where `TokenLimitInit` is `(address token, uint256 limit, uint48 windowDuration)`
+ */
+declare function encodeSpendingLimitInitData(policy: SpendingLimitPolicy, trustedForwarder?: Address): Hex;
+/**
+ * Encode AllowlistHook init data.
+ *
+ * Solidity: `abi.decode(data, (address, uint8, TargetPermission[], address[]))`
+ * where `TargetPermission` is `(address target, bytes4 selector)`
+ * and mode 0 = ALLOWLIST, 1 = BLOCKLIST
+ *
+ * The protectedAddresses array should include all infrastructure contract addresses
+ * (other hooks, HookMultiPlexer, AutomationExecutor) that must never be callable
+ * as execution targets, regardless of mode.
+ *
+ * NOTE: The wildcard selector is 0x431e2cf5 (keccak256("WILDCARD") truncated to 4 bytes).
+ * Do NOT use 0x00000000 as wildcard — that represents empty calldata (ETH transfers).
+ */
+declare function encodeAllowlistInitData(policy: AllowlistPolicy, trustedForwarder?: Address): Hex;
+/**
+ * Encode EmergencyPauseHook init data.
+ *
+ * Solidity: `abi.decode(data, (address, address, uint48))`
+ * trustedForwarder + guardian address + autoUnpauseAfter in seconds
+ */
+declare function encodeEmergencyPauseInitData(policy: EmergencyPausePolicy, trustedForwarder?: Address): Hex;
+
+/** ERC-7579 module type: Validator */
+declare const MODULE_TYPE_VALIDATOR = 1;
+/** ERC-7579 module type: Executor */
+declare const MODULE_TYPE_EXECUTOR = 2;
+/** ERC-7579 module type: Fallback */
+declare const MODULE_TYPE_FALLBACK = 3;
+/** ERC-7579 module type: Hook */
+declare const MODULE_TYPE_HOOK = 4;
+/** Native ETH represented as the zero address */
+declare const NATIVE_TOKEN: Address;
+/** ERC-4337 EntryPoint v0.7 (canonical address on all chains) */
+declare const ENTRYPOINT_V07: Address;
+/** Safe7579 module address (canonical) */
+declare const SAFE_7579_MODULE: Address;
+/** Safe7579 launchpad address (canonical) */
+declare const SAFE_7579_LAUNCHPAD: Address;
+/** Rhinestone module registry attester */
+declare const RHINESTONE_ATTESTER: Address;
+/** Time window constants (in seconds) */
+declare const WINDOW_1_HOUR = 3600;
+declare const WINDOW_1_DAY = 86400;
+declare const WINDOW_1_WEEK = 604800;
+declare const SPENDING_LIMIT_HOOK_ABI: readonly [{
+    readonly name: "setSpendingLimit";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "limit";
+        readonly type: "uint256";
+    }, {
+        readonly name: "windowDuration";
+        readonly type: "uint48";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "removeSpendingLimit";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "getRemainingAllowance";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "remaining";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "configs";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "limit";
+        readonly type: "uint256";
+    }, {
+        readonly name: "spent";
+        readonly type: "uint256";
+    }, {
+        readonly name: "windowDuration";
+        readonly type: "uint48";
+    }, {
+        readonly name: "windowStart";
+        readonly type: "uint48";
+    }];
+    readonly stateMutability: "view";
+}];
+declare const ALLOWLIST_HOOK_ABI: readonly [{
+    readonly name: "addPermission";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "target";
+        readonly type: "address";
+    }, {
+        readonly name: "selector";
+        readonly type: "bytes4";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "removePermission";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "target";
+        readonly type: "address";
+    }, {
+        readonly name: "selector";
+        readonly type: "bytes4";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "setMode";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "mode";
+        readonly type: "uint8";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "isTargetAllowed";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly name: "target";
+        readonly type: "address";
+    }, {
+        readonly name: "selector";
+        readonly type: "bytes4";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}];
+declare const EMERGENCY_PAUSE_HOOK_ABI: readonly [{
+    readonly name: "pause";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "unpause";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "isPaused";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "setGuardian";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "newGuardian";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "setAutoUnpauseTimeout";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "timeout";
+        readonly type: "uint48";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}];
+/** HookMultiPlexer canonical address (same on all chains) */
+declare const HOOK_MULTIPLEXER_ADDRESS: Address;
+/** HookType enum matching HookMultiPlexer.sol */
+declare const HOOK_TYPE_GLOBAL = 0;
+/** HookMultiPlexer.addHook ABI (for GLOBAL/VALUE/DELEGATECALL hooks) */
+declare const HOOK_MULTIPLEXER_ABI: readonly [{
+    readonly name: "addHook";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "hook";
+        readonly type: "address";
+    }, {
+        readonly name: "hookType";
+        readonly type: "uint8";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "removeHook";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "hook";
+        readonly type: "address";
+    }, {
+        readonly name: "hookType";
+        readonly type: "uint8";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}];
+/**
+ * Deployed module addresses per chain.
+ *
+ * @remarks This record is intentionally empty. After deploying contracts
+ * to a specific chain, populate this map or (preferably) supply addresses
+ * via `SmartAgentKitConfig.moduleAddresses` at runtime.
+ *
+ * @internal Exported for advanced usage; most users should configure
+ * addresses through SmartAgentKitConfig instead of relying on this map.
+ */
+declare const MODULE_ADDRESSES: Record<string, {
+    hookMultiPlexer: Address;
+    spendingLimitHook: Address;
+    allowlistHook: Address;
+    emergencyPauseHook: Address;
+    automationExecutor: Address;
+}>;
+
+/**
+ * Built-in deployment addresses per chain.
+ *
+ * Populated automatically by `deploy.sh` after contract deployment.
+ * When addresses are available, the SDK can auto-resolve them by chain ID,
+ * removing the need to manually specify `moduleAddresses` in config.
+ */
+declare const DEPLOYMENTS: Record<number, ModuleAddresses>;
+
+/**
+ * Base error class for SmartAgentKit SDK errors.
+ */
+declare class SmartAgentKitError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Thrown when wallet creation fails.
+ */
+declare class WalletCreationError extends SmartAgentKitError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Thrown when a policy configuration is invalid.
+ */
+declare class PolicyConfigError extends SmartAgentKitError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Thrown when transaction execution fails.
+ */
+declare class ExecutionError extends SmartAgentKitError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Thrown when a spending limit would be exceeded.
+ */
+declare class SpendingLimitExceededError extends SmartAgentKitError {
+    readonly token: string;
+    readonly attempted: bigint;
+    readonly remaining: bigint;
+    constructor(token: string, attempted: bigint, remaining: bigint);
+}
+/**
+ * Thrown when the wallet is paused.
+ */
+declare class WalletPausedError extends SmartAgentKitError {
+    readonly walletAddress: string;
+    constructor(walletAddress: string);
+}
+/**
+ * Thrown when a session key is invalid or expired.
+ */
+declare class SessionError extends SmartAgentKitError {
+    constructor(message: string, cause?: unknown);
+}
+
+/** Smart Sessions module address (canonical on all chains) */
+declare const SMART_SESSIONS_ADDRESS: Address;
+/** OwnableValidator — used as session key validator for ECDSA keys */
+declare const OWNABLE_VALIDATOR_ADDRESS: Address;
+/**
+ * Build a Smart Sessions `Session` struct from our SDK params.
+ *
+ * The session is scoped to:
+ * - Specific target contracts + function selectors (from actions)
+ * - Time-bound via TimeFramePolicy (from expiresAt)
+ * - Optional spending limits via SpendingLimitsPolicy
+ *
+ * @param sessionKeyAddress - The session key's public address (ECDSA)
+ * @param params - SDK-level session params
+ * @param chainId - Target chain ID
+ * @param sessionValidatorAddress - Override for the session validator contract
+ */
+declare function buildSession(sessionKeyAddress: Address, params: CreateSessionParams, chainId: bigint, sessionValidatorAddress?: Address): Session;
+/**
+ * Get the Smart Sessions Module for installation on the account.
+ * This module enables session key support on the smart account.
+ *
+ * @param sessions - Optional initial sessions to enable at install time
+ */
+declare function getSmartSessionsModule(sessions?: Session[]): _rhinestone_module_sdk.Module;
+/**
+ * Compute the permission ID for a session.
+ * This is a deterministic hash of the session configuration.
+ */
+declare function computePermissionId(session: Session): Hex;
+/**
+ * Encode a session signature for a UserOp in USE mode.
+ * Used when the session is already enabled on the account.
+ */
+declare function encodeUseSessionSignature(permissionId: Hex, signature: Hex): Hex;
+/**
+ * Encode a session signature for a UserOp in ENABLE mode.
+ * Used when enabling and using a session in the same UserOp.
+ */
+declare function encodeEnableSessionSignature(permissionId: Hex, signature: Hex, enableSessionData: EnableSessionData): Hex;
+/**
+ * Get the execution action to remove (revoke) a session.
+ * Returns a call that can be batched into a UserOp.
+ */
+declare function getRemoveAction(permissionId: Hex): {
+    to: Address;
+    value: bigint;
+    data: Hex;
+};
+
+export { ALLOWLIST_HOOK_ABI, type ActiveSession, type AgentWallet, type AllowlistPolicy, type AutomationPolicy, type CreateSessionParams, type CreateWalletParams, DEPLOYMENTS, EMERGENCY_PAUSE_HOOK_ABI, ENTRYPOINT_V07, type EmergencyPausePolicy, type EncodedPolicy, type ExecuteBatchParams, type ExecuteParams, ExecutionError, HOOK_MULTIPLEXER_ABI, HOOK_MULTIPLEXER_ADDRESS, HOOK_TYPE_GLOBAL, type ISmartAgentKitClient, type InstalledPolicy, MODULE_ADDRESSES, MODULE_TYPE_EXECUTOR, MODULE_TYPE_FALLBACK, MODULE_TYPE_HOOK, MODULE_TYPE_VALIDATOR, type MnemonicCredential, type ModuleAddresses, NATIVE_TOKEN, OWNABLE_VALIDATOR_ADDRESS, PRESETS, type PolicyConfig, PolicyConfigError, type PresetName, RHINESTONE_ATTESTER, SAFE_7579_LAUNCHPAD, SAFE_7579_MODULE, SMART_SESSIONS_ADDRESS, SPENDING_LIMIT_HOOK_ABI, type SessionAction, SessionError, type SessionRule, type SignerKey, SmartAgentKitClient, type SmartAgentKitConfig, SmartAgentKitError, SpendingLimitExceededError, type SpendingLimitPolicy, type TargetPermission, type TokenLimit, WINDOW_1_DAY, WINDOW_1_HOUR, WINDOW_1_WEEK, WalletCreationError, WalletPausedError, buildSession, computePermissionId, encodeAllowlistInitData, encodeEmergencyPauseInitData, encodeEnableSessionSignature, encodePolicyInitData, encodeSpendingLimitInitData, encodeUseSessionSignature, getRemoveAction as getRemoveSessionAction, getSmartSessionsModule };