@agether/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,932 @@
+import { Signer } from 'ethers';
+
+/**
+ * Agether SDK Types v2
+ *
+ * Account-based credit model:
+ * - Agent registers via ERC-8004 → gets agentId
+ * - AccountFactory creates AgentAccount (smart wallet) per agent
+ * - ReputationCredit: undercollateralized credit (LP-funded, Bayesian scoring)
+ * - MorphoCredit: overcollateralized credit (Morpho Blue)
+ * - Apply/approve pipeline: agent applies → scoring evaluates → admin approves/rejects on-chain
+ */
+declare enum CreditStatus {
+    None = 0,
+    Pending = 1,
+    Active = 2,
+    Frozen = 3,
+    Closed = 4,
+    Defaulted = 5
+}
+declare enum ChainId {
+    Ethereum = 1,
+    Base = 8453,
+    BaseSepolia = 84532,
+    Sepolia = 11155111,
+    Hardhat = 31337
+}
+/** ICreditProvider.CreditInfo view struct */
+interface CreditInfo {
+    limit: bigint;
+    used: bigint;
+    available: bigint;
+    accruedInterest: bigint;
+    aprBps: bigint;
+    isActive: boolean;
+    requiresCollateral: boolean;
+}
+/** ReputationCredit full credit line details */
+interface CreditLine {
+    agentId: bigint;
+    limit: bigint;
+    used: bigint;
+    aprBps: bigint;
+    accruedInterest: bigint;
+    requestedLimit: bigint;
+    createdAt: bigint;
+    lastActivityAt: bigint;
+    status: CreditStatus;
+}
+/** Credit application request */
+interface CreditApplication {
+    agentId: bigint;
+    requestedLimit: bigint;
+}
+/** Scored credit preview */
+interface ScoredLimitPreview {
+    limit: bigint;
+    score: bigint;
+    eligible: boolean;
+}
+/** AgentReputation data */
+interface AgentReputation {
+    totalBorrowed: bigint;
+    totalRepaid: bigint;
+    totalInterestPaid: bigint;
+    onTimePayments: bigint;
+    latePayments: bigint;
+    missedPayments: bigint;
+    peakUtilization: bigint;
+    avgUtilization: bigint;
+    utilizationSamples: bigint;
+    firstActivityAt: bigint;
+    lastActivityAt: bigint;
+    lastScoreUpdate: bigint;
+    creditScore: bigint;
+    creditLinesOpened: bigint;
+    lastCreditOpenedAt: bigint;
+    currentOutstanding: bigint;
+    currentLimit: bigint;
+    totalDeposits: bigint;
+    totalWithdrawals: bigint;
+}
+/** Loan position tracked by AgentReputation (OCCR model) */
+interface LoanPosition {
+    amount: bigint;
+    collateral: bigint;
+    ltvBps: bigint;
+    timestamp: bigint;
+    liquidated: boolean;
+    repaid: boolean;
+    active: boolean;
+}
+/** OCCR score explanation (5 subscores + raw/decayed) */
+interface ScoreExplanation {
+    historical: bigint;
+    currentRisk: bigint;
+    utilization: bigint;
+    onChainTx: bigint;
+    newCredit: bigint;
+    rawScore: bigint;
+    decayedScore: bigint;
+}
+/** Bayesian score result */
+interface BayesianScore {
+    combinedScore: bigint;
+    confidence: bigint;
+}
+interface ScoringRequest {
+    agentId: bigint;
+    requestedLimit: bigint;
+    codeHash?: string;
+}
+interface ScoringResult {
+    approved: boolean;
+    limit: bigint;
+    aprBps: number;
+    riskScore: number;
+    bayesianScore: number;
+    confidence: number;
+    reason?: string;
+}
+interface DrawRequest {
+    account: string;
+    amount: bigint;
+}
+interface RepayRequest {
+    account: string;
+    amount: bigint;
+}
+interface TransactionResult {
+    txHash: string;
+    blockNumber: number;
+    status: 'success' | 'failed';
+    gasUsed: bigint;
+}
+interface X402PaymentRequest {
+    service: string;
+    amount: bigint;
+    asset: string;
+    chain: ChainId;
+    recipient: string;
+}
+interface X402PaymentResult {
+    paymentId: string;
+    txHash: string;
+    amount: bigint;
+    chain: ChainId;
+    status: 'pending' | 'confirmed' | 'failed';
+}
+interface VaultStats {
+    totalAssets: bigint;
+    totalBorrowed: bigint;
+    availableLiquidity: bigint;
+    utilizationRate: number;
+    sharePrice: bigint;
+}
+interface LPPosition {
+    shares: bigint;
+    assets: bigint;
+    pendingYield: bigint;
+}
+interface AgetherConfig {
+    chainId: ChainId;
+    rpcUrl: string;
+    contracts: ContractAddresses;
+    scoringEndpoint?: string;
+    kyaEndpoint?: string;
+}
+interface ContractAddresses {
+    accountFactory: string;
+    reputationCredit: string;
+    lpVault: string;
+    validationRegistry: string;
+    usdc: string;
+    identityRegistry: string;
+    morphoCredit?: string;
+    agentReputation?: string;
+}
+interface CreditAppliedEvent {
+    agentId: bigint;
+    account: string;
+    requestedLimit: bigint;
+    timestamp: number;
+}
+interface CreditApprovedEvent {
+    account: string;
+    limit: bigint;
+    aprBps: bigint;
+    timestamp: number;
+}
+interface CreditRejectedEvent {
+    account: string;
+    reason: string;
+    timestamp: number;
+}
+interface CreditDrawnEvent {
+    account: string;
+    amount: bigint;
+    totalUsed: bigint;
+    timestamp: number;
+}
+interface CreditRepaidEvent {
+    account: string;
+    amount: bigint;
+    totalUsed: bigint;
+    timestamp: number;
+}
+declare class AgetherError extends Error {
+    code: string;
+    details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
+}
+declare class InsufficientCreditError extends AgetherError {
+    constructor(available: bigint, requested: bigint);
+}
+declare class ScoringRejectedError extends AgetherError {
+    constructor(riskScore: number, reason?: string);
+}
+declare class CreditNotActiveError extends AgetherError {
+    constructor(account: string, status: CreditStatus);
+}
+
+interface AgetherClientOptions {
+    config: AgetherConfig;
+    signer: Signer;
+    agentId: bigint;
+}
+declare class AgetherClient {
+    private config;
+    private signer;
+    private agentId;
+    private accountFactory;
+    private reputationCredit;
+    private accountAddress?;
+    /**
+     * Undercollateralized credit is disabled for now.
+     * All credit operations go through MorphoCredit (overcollateralized).
+     */
+    private _requireUndercollateralizedEnabled;
+    constructor(options: AgetherClientOptions);
+    /**
+     * Create client from private key.
+     *
+     * Simplest usage — only needs key, agentId, and chainId:
+     *   AgetherClient.fromPrivateKey(key, 42n, ChainId.Sepolia)
+     *
+     * All contract addresses and RPC URLs are resolved automatically.
+     */
+    static fromPrivateKey(privateKey: string, agentId: bigint, chainIdOrConfig: ChainId | AgetherConfig): AgetherClient;
+    /**
+     * Create an AgentAccount (smart wallet) for this agent.
+     * Returns the account address.
+     */
+    createAccount(): Promise<string>;
+    /**
+     * Get the AgentAccount address for this agent.
+     */
+    getAccountAddress(): Promise<string>;
+    /**
+     * Check if an account already exists.
+     */
+    accountExists(): Promise<boolean>;
+    /**
+     * Apply for a credit line.
+     * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+     */
+    apply(_limitOrApplication: bigint | CreditApplication): Promise<string>;
+    /**
+     * Get full credit line details from ReputationCredit.
+     */
+    getCreditLine(): Promise<CreditLine>;
+    /**
+     * Get ICreditProvider.CreditInfo view.
+     */
+    getCreditInfo(): Promise<CreditInfo>;
+    /**
+     * Get credit line status.
+     */
+    getStatus(): Promise<CreditStatus>;
+    /**
+     * Get available credit.
+     */
+    getAvailableCredit(): Promise<bigint>;
+    /**
+     * Get total debt (principal + interest).
+     */
+    getTotalDebt(): Promise<bigint>;
+    /**
+     * Check if agent is eligible for credit.
+     */
+    isEligible(): Promise<boolean>;
+    /**
+     * Draw funds from credit line via AgentAccount.
+     * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+     */
+    draw(_amountOrRequest: bigint | DrawRequest): Promise<TransactionResult>;
+    /**
+     * Repay credit line debt via AgentAccount.
+     * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+     */
+    repay(_amountOrRequest: bigint | RepayRequest): Promise<TransactionResult>;
+    /**
+     * Repay full debt.
+     * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+     */
+    repayFull(): Promise<TransactionResult>;
+    /**
+     * Request a limit increase on-chain.
+     * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+     */
+    requestLimitIncrease(_newLimit: bigint): Promise<string>;
+    /**
+     * Pay for a service using credit line.
+     * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+     */
+    pay(_service: string, _amount: bigint, _asset?: string): Promise<TransactionResult>;
+    get chainId(): ChainId;
+    get contracts(): ContractAddresses;
+    get currentAccountAddress(): string | undefined;
+    /** Get the underlying signer */
+    getSigner(): Signer;
+}
+
+/**
+ * ScoringClient - Client for the Agether backend scoring API (v2)
+ *
+ * Connects to backend service at /credit/* and /admin/* endpoints.
+ * The backend evaluates agents based on:
+ * - On-chain reputation (AgentReputation contract, Bayesian scoring)
+ * - Code audit status (ValidationRegistry)
+ * - Default history
+ * - Risk model
+ *
+ * v2: account-based (not creditLineId-based)
+ */
+
+interface ScoringContext {
+    purpose?: string;
+    reasoningTrace?: string[];
+    runtimeEnv?: string;
+}
+interface RiskCheckResponse {
+    riskScore: number;
+    level: 'low' | 'medium' | 'high';
+    wouldApprove: boolean;
+    factors: RiskFactor[];
+}
+interface RiskFactor {
+    name: string;
+    score: number;
+    weight: number;
+    description: string;
+}
+interface GraduationStatus {
+    eligible: boolean;
+    reason: string;
+    stats: {
+        onTimeRepayments: number;
+        totalVolume: string;
+        creditScore: number;
+    };
+}
+declare class ScoringClient {
+    private client;
+    constructor(endpoint: string, apiKey?: string);
+    /**
+     * Evaluate a credit application (does not submit on-chain)
+     * Backend endpoint: POST /credit/evaluate
+     */
+    evaluateCredit(request: ScoringRequest): Promise<ScoringResult>;
+    /**
+     * Process a credit application (evaluate + on-chain approve/reject)
+     * Backend endpoint: POST /admin/credit/process
+     *
+     * Requires the credit application to be in Pending status on-chain
+     * (agent must have called applyForCredit first).
+     */
+    processApplication(agentId: bigint, requestedLimit: bigint, codeHash?: string): Promise<{
+        success: boolean;
+        txHash?: string;
+        error?: string;
+    }>;
+    /**
+     * Get credit score for an agent
+     * Backend endpoint: GET /credit/score/:agentId
+     */
+    getCreditScore(agentId: bigint): Promise<{
+        agentId: string;
+        creditScore: number;
+        bayesianScore: number;
+        confidence: number;
+    }>;
+    /**
+     * Preview scored limit for an agent
+     * Backend endpoint: GET /credit/preview/:agentId
+     */
+    previewScoredLimit(agentId: bigint): Promise<{
+        limit: string;
+        score: string;
+        eligible: boolean;
+    }>;
+    /**
+     * Get credit line info for an agent
+     * Backend endpoint: GET /credit/agent/:agentId
+     */
+    getAgentCredit(agentId: bigint): Promise<{
+        agentId: string;
+        account: string;
+        creditInfo: Record<string, unknown>;
+        creditLine: Record<string, unknown>;
+    }>;
+    /**
+     * Get protocol info
+     * Backend endpoint: GET /credit/protocol-info
+     */
+    getProtocolInfo(): Promise<{
+        dailyDrawLimit: string;
+        totalBorrowed: string;
+        asset: string;
+    }>;
+    /**
+     * Get backend service status
+     * Backend endpoint: GET /status
+     */
+    getStatus(): Promise<{
+        status: string;
+        version: string;
+        signer: string;
+        contracts: {
+            healthy: boolean;
+        };
+    }>;
+    /**
+     * Get full OCCR score explanation with subscores, decay, and loan positions
+     * Backend endpoint: GET /agents/:agentId/score-explanation
+     */
+    getScoreExplanation(agentId: bigint): Promise<{
+        agentId: string;
+        subscores: {
+            historical: number;
+            currentRisk: number;
+            utilization: number;
+            onChainTx: number;
+            newCredit: number;
+        };
+        rawScore: number;
+        decayedScore: number;
+        stressMultiplier: number;
+        decayPeriod: number;
+        loanPositions: Array<{
+            amount: string;
+            collateral: string;
+            ltvBps: number;
+            timestamp: number;
+            liquidated: boolean;
+            repaid: boolean;
+            active: boolean;
+        }>;
+    }>;
+}
+
+/**
+ * VaultClient - Client for liquidity providers
+ */
+
+interface VaultClientOptions {
+    config: AgetherConfig;
+    signer: Signer;
+}
+declare class VaultClient {
+    private config;
+    private signer;
+    private vault;
+    private asset?;
+    constructor(options: VaultClientOptions);
+    /**
+     * Deposit assets to vault
+     */
+    deposit(amount: bigint): Promise<TransactionResult>;
+    /**
+     * Withdraw assets from vault
+     */
+    withdraw(amount: bigint): Promise<TransactionResult>;
+    /**
+     * Redeem shares for assets
+     */
+    redeem(shares: bigint): Promise<TransactionResult>;
+    /**
+     * Get vault statistics
+     */
+    getStats(): Promise<VaultStats>;
+    /**
+     * Get LP position
+     */
+    getPosition(address?: string): Promise<LPPosition>;
+    /**
+     * Preview deposit (how many shares for assets)
+     */
+    previewDeposit(assets: bigint): Promise<bigint>;
+    /**
+     * Preview withdraw (how many assets for shares)
+     */
+    previewRedeem(shares: bigint): Promise<bigint>;
+    /**
+     * Check if withdrawal is allowed (sufficient liquidity)
+     */
+    canWithdraw(assets: bigint): Promise<boolean>;
+    /**
+     * Get current APY estimate
+     */
+    estimateAPY(): Promise<number>;
+    private getAsset;
+    /**
+     * Get underlying asset address
+     */
+    getAssetAddress(): Promise<string>;
+    /**
+     * Get vault share token address
+     */
+    getVaultAddress(): string;
+}
+
+/**
+ * AgentIdentityClient - Integration with ag0 (ERC-8004)
+ *
+ * ERC-8004 Contract Addresses:
+ * - Sepolia IdentityRegistry: 0x8004A818BFB912233c491871b3d84c89A494BD9e
+ * - Sepolia ReputationRegistry: 0x8004B663056A597Dffe9eCcC1965A193B7388713
+ *
+ * SDKs:
+ * - TypeScript: https://github.com/agent0lab/agent0-ts
+ * - Python: https://github.com/agent0lab/agent0-py
+ *
+ * Docs: https://sdk.ag0.xyz/docs
+ */
+
+interface AgentIdentityClientOptions {
+    config: AgetherConfig;
+    signer: Signer;
+    /** Optional: Use ag0 TypeScript SDK instead of direct contracts */
+    useAg0SDK?: boolean;
+}
+interface AgentMetadata {
+    name: string;
+    description: string;
+    image?: string;
+    endpoints?: {
+        name: string;
+        endpoint: string;
+        version?: string;
+    }[];
+    x402Support?: boolean;
+    active?: boolean;
+}
+interface FeedbackInput {
+    agentId: bigint;
+    value: number;
+    decimals?: number;
+    tag1?: string;
+    tag2?: string;
+    endpoint?: string;
+    feedbackURI?: string;
+}
+interface ReputationSummary {
+    count: number;
+    totalValue: number;
+    averageValue: number;
+    clients: string[];
+}
+declare class AgentIdentityClient {
+    readonly config: AgetherConfig;
+    private signer;
+    private identityRegistry;
+    private reputationRegistry;
+    constructor(options: AgentIdentityClientOptions);
+    /**
+     * Register a new agent (minimal - no metadata)
+     */
+    register(): Promise<{
+        agentId: bigint;
+        txHash: string;
+    }>;
+    /**
+     * Register agent with IPFS/HTTP URI to metadata JSON
+     * @param agentURI URI pointing to agent metadata (ipfs:// or https://)
+     */
+    registerWithURI(agentURI: string): Promise<{
+        agentId: bigint;
+        txHash: string;
+    }>;
+    /**
+     * Check if the signer already owns an ERC-8004 identity token.
+     * Returns true if balanceOf > 0, false otherwise.
+     * Note: Cannot determine the specific agentId without enumeration —
+     * use agether init <pk> --agent-id <id> if you know your agentId.
+     */
+    hasExistingIdentity(): Promise<boolean>;
+    /**
+     * Register only if no identity exists; otherwise throw.
+     * Prevents accidental double-registration.
+     */
+    registerOrGet(): Promise<{
+        agentId: bigint;
+        txHash: string | null;
+        existing: boolean;
+    }>;
+    /**
+     * Register with URI only if no identity exists; otherwise throw.
+     * Prevents accidental double-registration.
+     */
+    registerOrGetWithURI(agentURI: string): Promise<{
+        agentId: bigint;
+        txHash: string | null;
+        existing: boolean;
+    }>;
+    /**
+     * Register agent with URI and on-chain metadata
+     */
+    registerWithMetadata(agentURI: string, metadata: {
+        key: string;
+        value: string;
+    }[]): Promise<{
+        agentId: bigint;
+        txHash: string;
+    }>;
+    /**
+     * Get agent owner address
+     */
+    getOwner(agentId: bigint): Promise<string>;
+    /**
+     * Get agent URI (metadata JSON location)
+     */
+    getAgentURI(agentId: bigint): Promise<string>;
+    /**
+     * Update agent URI
+     */
+    setAgentURI(agentId: bigint, newURI: string): Promise<string>;
+    /**
+     * Set on-chain metadata (key-value)
+     */
+    setMetadata(agentId: bigint, key: string, value: string): Promise<string>;
+    /**
+     * Get on-chain metadata
+     */
+    getMetadata(agentId: bigint, key: string): Promise<string>;
+    /**
+     * Transfer agent to new owner
+     */
+    transfer(agentId: bigint, to: string): Promise<string>;
+    /**
+     * Fetch and parse agent metadata from URI
+     */
+    fetchAgentMetadata(agentId: bigint): Promise<AgentMetadata | null>;
+    /**
+     * Give feedback to an agent
+     */
+    giveFeedback(input: FeedbackInput): Promise<string>;
+    /**
+     * Give positive feedback (shorthand)
+     */
+    givePosisitiveFeedback(agentId: bigint, value?: number, tags?: {
+        tag1?: string;
+        tag2?: string;
+    }): Promise<string>;
+    /**
+     * Give negative feedback (e.g., for defaults)
+     */
+    giveNegativeFeedback(agentId: bigint, value?: number, tags?: {
+        tag1?: string;
+        tag2?: string;
+    }): Promise<string>;
+    /**
+     * Record credit default in reputation system
+     */
+    recordCreditDefault(agentId: bigint, creditLineId: bigint): Promise<string>;
+    /**
+     * Get reputation summary for an agent
+     */
+    getReputation(agentId: bigint, tag1?: string, tag2?: string): Promise<ReputationSummary>;
+    /**
+     * Check if agent has negative credit reputation
+     */
+    hasNegativeCreditReputation(agentId: bigint): Promise<boolean>;
+    /**
+     * Verify agent is eligible for Agether credit
+     * Checks:
+     * 1. Agent exists in ERC-8004 registry
+     * 2. Agent has no negative credit reputation
+     */
+    verifyForCredit(agentId: bigint): Promise<{
+        eligible: boolean;
+        reason?: string;
+        owner?: string;
+        reputation?: ReputationSummary;
+    }>;
+    private parseAgentIdFromReceipt;
+    /**
+     * Get contract addresses
+     */
+    getContractAddresses(): {
+        identity: string;
+        reputation: string;
+    };
+}
+
+/**
+ * x402 HTTP Client — Make paid API calls via the x402 protocol (v2)
+ *
+ * Implements the Coinbase x402 spec:
+ *   https://github.com/coinbase/x402
+ *
+ * Flow:
+ *   1. Client → Resource Server (normal request)
+ *   2. Resource Server → 402 with PaymentRequired JSON body
+ *      Body: { x402Version, error, resource, accepts: [PaymentRequirements…] }
+ *   3. Client picks a PaymentRequirements from `accepts`,
+ *      signs an EIP-3009 transferWithAuthorization (EIP-712 typed data),
+ *      builds a PaymentPayload, base64-encodes it as PAYMENT-SIGNATURE header
+ *   4. Client → Resource Server (retries with PAYMENT-SIGNATURE)
+ *   5. Resource Server forwards to Facilitator /verify → /settle
+ *   6. Resource Server → 200 + data  (or error)
+ *
+ * Chain support: Base (8453), Ethereum (1), and Hardhat fork (31337).
+ * USDC domain is resolved per-chain from USDC_DOMAINS map.
+ */
+interface X402Config {
+    privateKey: string;
+    rpcUrl: string;
+    backendUrl: string;
+    agentId?: string;
+    accountAddress?: string;
+}
+interface X402Response<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    paymentInfo?: {
+        amount: string;
+        asset: string;
+        network: string;
+        txHash?: string;
+    };
+}
+/** One item inside the `accepts` array returned by the resource server */
+interface PaymentRequirements {
+    scheme: string;
+    network: string;
+    amount: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown>;
+}
+declare class X402Client {
+    private wallet;
+    private config;
+    constructor(config: X402Config);
+    get<T = unknown>(url: string, opts?: RequestInit): Promise<X402Response<T>>;
+    post<T = unknown>(url: string, body?: unknown, opts?: RequestInit): Promise<X402Response<T>>;
+    getAddress(): string;
+    private request;
+    private parsePaymentRequired;
+    private buildPaymentPayload;
+    private riskCheck;
+}
+
+/**
+ * WalletClient - SDK for AgentAccount (smart wallet) operations (v2)
+ *
+ * Handles:
+ * - Account creation and lookup via AccountFactory
+ * - Funding and withdrawing tokens
+ * - Drawing/repaying credit via AgentAccount
+ * - Token balance queries
+ */
+interface WalletInfo {
+    address: string;
+    agentId: bigint;
+    owner: string;
+    ethBalance: bigint;
+    usdcBalance: bigint;
+}
+interface ProviderStatus {
+    provider: string;
+    isEligible: boolean;
+    totalDebt: bigint;
+    maxDrawable: bigint;
+}
+interface MorphoMarketParams {
+    loanToken: string;
+    collateralToken: string;
+    oracle: string;
+    irm: string;
+    lltv: bigint;
+}
+interface PaymentProof {
+    recipient: string;
+    amount: bigint;
+    nonce: bigint;
+    deadline: bigint;
+    signature: string;
+}
+interface WalletClientConfig {
+    rpcUrl: string;
+    chainId: number;
+    factoryAddress: string;
+    usdcAddress?: string;
+    privateKey?: string;
+}
+declare class WalletClient {
+    private provider;
+    private privateKey;
+    private factoryAddress;
+    private usdcAddress;
+    private chainId;
+    private rpcUrl;
+    constructor(config: WalletClientConfig);
+    /**
+     * Create a fresh signer to avoid nonce caching issues
+     */
+    private getFreshSigner;
+    private getFactoryContract;
+    private getAccountContract;
+    getChainId(): number;
+    accountExists(agentId: bigint): Promise<boolean>;
+    getAccount(agentId: bigint): Promise<string | null>;
+    predictAddress(agentId: bigint): Promise<string>;
+    createAccount(agentId: bigint): Promise<string>;
+    totalAccounts(): Promise<bigint>;
+    getWalletInfo(accountAddress: string): Promise<WalletInfo>;
+    getProviderStatus(accountAddress: string, creditProvider: string): Promise<ProviderStatus>;
+    fundAccount(accountAddress: string, tokenAddress: string, amount: bigint): Promise<string>;
+    withdraw(accountAddress: string, tokenAddress: string, amount: bigint, to?: string): Promise<string>;
+    drawCredit(accountAddress: string, creditProvider: string, amount: bigint): Promise<string>;
+    repayCredit(accountAddress: string, creditProvider: string, amount: bigint): Promise<string>;
+    execute(accountAddress: string, target: string, value: bigint, data: string): Promise<string>;
+    generatePaymentMessageHash(accountAddress: string, recipient: string, amount: bigint, nonce: bigint, deadline: bigint, chainId: number): string;
+}
+
+/**
+ * Formatting utilities
+ */
+/**
+ * Parse units (e.g., "100" USDC -> 100000000n)
+ */
+declare function parseUnits(value: string, decimals?: number): bigint;
+/**
+ * Format units (e.g., 100000000n -> "100.00" USDC)
+ */
+declare function formatUnits(value: bigint, decimals?: number): string;
+/**
+ * Format USD value
+ */
+declare function formatUSD(value: bigint, decimals?: number): string;
+/**
+ * Format percentage
+ */
+declare function formatPercent(bps: number): string;
+/**
+ * Format APR from basis points
+ */
+declare function formatAPR(bps: bigint): string;
+/**
+ * Calculate health factor display
+ */
+declare function formatHealthFactor(factor: bigint): string;
+/**
+ * Format address (truncate)
+ */
+declare function formatAddress(address: string): string;
+/**
+ * Format timestamp to date
+ */
+declare function formatTimestamp(timestamp: bigint): string;
+/**
+ * Convert basis points to decimal rate
+ */
+declare function bpsToRate(bps: bigint): number;
+/**
+ * Convert decimal rate to basis points
+ */
+declare function rateToBps(rate: number): bigint;
+
+/**
+ * Network configurations (v2)
+ *
+ * v2 contract architecture:
+ * - AccountFactory + AgentAccount (smart wallets)
+ * - ReputationCredit (ICreditProvider, undercollateralized)
+ * - LPVault (ERC-4626)
+ * - ValidationRegistry (KYA)
+ * - AgentReputation (Bayesian scoring)
+ * - ERC-8004 IdentityRegistry
+ *
+ * All contract addresses are baked in — agents only need to specify chainId.
+ */
+
+/**
+ * Get default config for a chain — includes all addresses, RPC, and scoring endpoint.
+ */
+declare function getDefaultConfig(chainId: ChainId): AgetherConfig;
+/**
+ * Create custom config (override any defaults)
+ */
+declare function createConfig(chainId: ChainId, options?: Partial<AgetherConfig>): AgetherConfig;
+/**
+ * Get USDC address for chain
+ */
+declare function getUSDCAddress(chainId: ChainId): string;
+
+/**
+ * Contract ABIs v2 (minimal for SDK)
+ *
+ * v2 architecture:
+ * - AccountFactory + AgentAccount (smart wallets)
+ * - ReputationCredit (undercollateralized, ICreditProvider)
+ * - MorphoCredit (overcollateralized, ICreditProvider)
+ * - LPVault (ERC-4626)
+ * - ValidationRegistry (KYA)
+ * - AgentReputation (Bayesian scoring)
+ */
+declare const IDENTITY_REGISTRY_ABI: string[];
+declare const ACCOUNT_FACTORY_ABI: string[];
+declare const AGENT_ACCOUNT_ABI: string[];
+declare const CREDIT_PROVIDER_ABI: string[];
+declare const REPUTATION_CREDIT_ABI: string[];
+declare const LP_VAULT_ABI: string[];
+declare const AGENT_REPUTATION_ABI: string[];
+declare const VALIDATION_REGISTRY_ABI: string[];
+declare const ERC20_ABI: string[];
+
+export { ACCOUNT_FACTORY_ABI, AGENT_ACCOUNT_ABI, AGENT_REPUTATION_ABI, AgentIdentityClient, type AgentIdentityClientOptions, type AgentReputation, AgetherClient, type AgetherClientOptions, type AgetherConfig, AgetherError, type BayesianScore, CREDIT_PROVIDER_ABI, ChainId, type ContractAddresses, type CreditApplication, type CreditAppliedEvent, type CreditApprovedEvent, type CreditDrawnEvent, type CreditInfo, type CreditLine, CreditNotActiveError, type CreditRejectedEvent, type CreditRepaidEvent, CreditStatus, type DrawRequest, ERC20_ABI, type GraduationStatus, IDENTITY_REGISTRY_ABI, InsufficientCreditError, type LPPosition, LP_VAULT_ABI, type LoanPosition, type MorphoMarketParams, type PaymentProof, type PaymentRequirements, type ProviderStatus, REPUTATION_CREDIT_ABI, type RepayRequest, type RiskCheckResponse, type RiskFactor, type ScoreExplanation, type ScoredLimitPreview, ScoringClient, type ScoringContext, ScoringRejectedError, type ScoringRequest, type ScoringResult, type TransactionResult, VALIDATION_REGISTRY_ABI, VaultClient, type VaultClientOptions, type VaultStats, WalletClient, type WalletClientConfig, type WalletInfo, X402Client, type X402Config, type X402PaymentRequest, type X402PaymentResult, type X402Response, bpsToRate, createConfig, formatAPR, formatAddress, formatHealthFactor, formatPercent, formatTimestamp, formatUSD, formatUnits, getDefaultConfig, getUSDCAddress, parseUnits, rateToBps };