@agether/sdk 1.4.0 → 1.5.0

package/dist/index.d.ts

@@ -1,23 +1,15 @@
 import { Signer } from 'ethers';
 
 /**
- * Agether SDK Types v2
+ * Agether SDK Types
  *
- * Account-based credit model:
+ * Architecture:
  * - 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
+ * - AccountFactory creates AgentAccount (KYA-gated smart wallet) per agent
+ * - AgentReputation: oracle-based credit scoring
+ * - Morpho Blue: direct overcollateralized lending (agents interact directly)
+ * - x402: HTTP payment protocol for scoring API
  */
-declare enum CreditStatus {
-    None = 0,
-    Pending = 1,
-    Active = 2,
-    Frozen = 3,
-    Closed = 4,
-    Defaulted = 5
-}
 declare enum ChainId {
     Ethereum = 1,
     Base = 8453,
@@ -25,107 +17,59 @@ declare enum ChainId {
     Sepolia = 11155111,
     Hardhat = 31337
 }
-/** ICreditProvider.CreditInfo view struct */
-interface CreditInfo {
-    limit: bigint;
-    used: bigint;
-    available: bigint;
-    accruedInterest: bigint;
-    aprBps: bigint;
-    isActive: boolean;
-    requiresCollateral: boolean;
+/** Morpho Blue MarketParams struct */
+interface MorphoMarketParams {
+    loanToken: string;
+    collateralToken: string;
+    oracle: string;
+    irm: string;
+    lltv: bigint;
 }
-/** 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;
+/** Morpho Blue on-chain position for an account */
+interface MorphoPosition {
+    supplyShares: bigint;
+    borrowShares: bigint;
+    collateral: bigint;
 }
-/** Credit application request */
-interface CreditApplication {
-    agentId: bigint;
-    requestedLimit: bigint;
+/** Morpho market info (from GraphQL API or on-chain) */
+interface MorphoMarketInfo {
+    uniqueKey: string;
+    loanAsset: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    collateralAsset: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    oracle: string;
+    irm: string;
+    lltv: bigint;
+    totalSupplyAssets: bigint;
+    totalBorrowAssets: bigint;
+    utilization: number;
 }
-/** Scored credit preview */
-interface ScoredLimitPreview {
-    limit: bigint;
+/** On-chain score attestation from AgentReputation contract */
+interface ScoreAttestation {
     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;
+    signer: 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;
+/** Score result from backend scoring API */
+interface ScoreResult {
+    agentId: string;
+    score: number;
+    timestamp: number;
+    breakdown: {
+        kyaBonus: number;
+        accountBonus: number;
+        balanceBonus: number;
+        historyBonus: number;
+        baseScore: number;
+    };
+    txHash?: string;
 }
 interface TransactionResult {
     txHash: string;
@@ -147,18 +91,6 @@ interface X402PaymentResult {
     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;
@@ -168,56 +100,25 @@ interface AgetherConfig {
 }
 interface ContractAddresses {
     accountFactory: string;
-    reputationCredit: string;
-    lpVault: string;
     validationRegistry: string;
+    agentReputation: 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;
+    morphoBlue: string;
 }
 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 InsufficientBalanceError extends AgetherError {
+    constructor(available: bigint, required: bigint);
 }
 declare class ScoringRejectedError extends AgetherError {
     constructor(riskScore: number, reason?: string);
 }
-declare class CreditNotActiveError extends AgetherError {
-    constructor(account: string, status: CreditStatus);
+declare class AgentNotApprovedError extends AgetherError {
+    constructor(agentId: bigint);
 }
 
 interface AgetherClientOptions {
@@ -230,294 +131,414 @@ declare class AgetherClient {
     private signer;
     private agentId;
     private accountFactory;
-    private reputationCredit;
+    private identityRegistry;
+    private validationRegistry;
+    private agentReputation;
     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>;
+    predictAddress(): Promise<string>;
+    getBalances(): Promise<{
+        eoa: {
+            eth: string;
+            usdc: string;
+        };
+        account?: {
+            address: string;
+            eth: string;
+            usdc: string;
+        };
+    }>;
+    fundAccount(usdcAmount: string): Promise<TransactionResult>;
+    withdrawUsdc(usdcAmount: string): Promise<TransactionResult>;
+    withdrawEth(ethAmount: string): Promise<TransactionResult>;
+    isKyaApproved(): Promise<boolean>;
+    identityExists(): Promise<boolean>;
+    getIdentityOwner(): Promise<string>;
+    getCreditScore(): Promise<bigint>;
+    isScoreFresh(): Promise<{
+        fresh: boolean;
+        age: bigint;
+    }>;
+    isEligible(minScore?: bigint): Promise<{
+        eligible: boolean;
+        currentScore: bigint;
+    }>;
     get chainId(): ChainId;
     get contracts(): ContractAddresses;
     get currentAccountAddress(): string | undefined;
-    /** Get the underlying signer */
     getSigner(): Signer;
+    getAgentId(): bigint;
 }
 
 /**
- * ScoringClient - Client for the Agether backend scoring API (v2)
+ * MorphoClient — Direct Morpho Blue lending via AgentAccount.executeBatch
  *
- * 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
+ * Architecture (no intermediary contract):
+ *   EOA → AgentAccount.executeBatch → Morpho Blue (direct)
  *
- * v2: account-based (not creditLineId-based)
+ * Batched operations:
+ *   - depositAndBorrow: [ERC20.approve, Morpho.supplyCollateral, Morpho.borrow]
+ *   - repay:            [ERC20.approve, Morpho.repay]
+ *   - supplyCollateral:  [ERC20.approve, Morpho.supplyCollateral]
+ *
+ * Market discovery via Morpho GraphQL API (https://api.morpho.org/graphql)
  */
 
-interface ScoringContext {
-    purpose?: string;
-    reasoningTrace?: string[];
-    runtimeEnv?: string;
+interface MorphoClientConfig {
+    privateKey: string;
+    rpcUrl: string;
+    agentId?: string;
+    chainId?: ChainId;
+    contracts?: Partial<{
+        accountFactory: string;
+        morphoBlue: string;
+        usdc: string;
+        agentReputation: string;
+        identityRegistry: string;
+    }>;
+}
+interface BalancesResult {
+    agentId: string;
+    address: string;
+    eth: string;
+    usdc: string;
+    agentAccount?: {
+        address: string;
+        eth: string;
+        usdc: string;
+    };
 }
-interface RiskCheckResponse {
-    riskScore: number;
-    level: 'low' | 'medium' | 'high';
-    wouldApprove: boolean;
-    factors: RiskFactor[];
+interface RegisterResult {
+    agentId: string;
+    address: string;
+    agentAccount: string;
+    alreadyRegistered: boolean;
+    tx?: string;
 }
-interface RiskFactor {
-    name: string;
-    score: number;
-    weight: number;
-    description: string;
+interface PositionResult {
+    marketId: string;
+    collateralToken: string;
+    collateral: string;
+    borrowShares: string;
+    supplyShares: string;
+    debt: string;
 }
-interface GraduationStatus {
-    eligible: boolean;
-    reason: string;
-    stats: {
-        onTimeRepayments: number;
-        totalVolume: string;
-        creditScore: number;
-    };
+interface StatusResult {
+    agentId: string;
+    agentAccount: string;
+    totalDebt: string;
+    positions: PositionResult[];
 }
-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>;
+interface DepositResult {
+    tx: string;
+    collateralToken: string;
+    amount: string;
+    agentAccount: string;
+}
+interface BorrowResult {
+    tx: string;
+    amount: string;
+    collateralToken: string;
+    agentAccount: string;
+}
+interface DepositAndBorrowResult {
+    tx: string;
+    collateralToken: string;
+    collateralAmount: string;
+    borrowAmount: string;
+    agentAccount: string;
+}
+interface RepayResult {
+    tx: string;
+    amount: string;
+    remainingDebt: string;
+}
+interface WithdrawResult {
+    tx: string;
+    token: string;
+    amount: string;
+    remainingCollateral: string;
+    destination: string;
+}
+interface FundResult {
+    tx: string;
+    amount: string;
+    agentAccount: string;
+}
+declare class MorphoClient {
+    private wallet;
+    private provider;
+    private config;
+    private agentId;
+    private accountFactory;
+    private morphoBlue;
+    private agentReputation;
+    private identityRegistry;
+    private _accountAddress?;
+    private _marketCache;
+    private _discoveredMarkets?;
+    private _discoveredAt;
+    constructor(config: MorphoClientConfig);
+    /** Resolve the AgentAccount address (cached). */
+    getAccountAddress(): Promise<string>;
+    getAgentId(): string;
+    getWalletAddress(): string;
     /**
-     * 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).
+     * Register: create ERC-8004 identity + AgentAccount in one flow.
+     * If already registered, returns existing state.
      */
-    processApplication(agentId: bigint, requestedLimit: bigint, codeHash?: string): Promise<{
-        success: boolean;
-        txHash?: string;
-        error?: string;
-    }>;
+    register(_name?: string): Promise<RegisterResult>;
+    /** Get ETH / USDC balances for EOA and AgentAccount. */
+    getBalances(): Promise<BalancesResult>;
+    /** Transfer USDC from EOA to AgentAccount. */
+    fundAccount(usdcAmount: string): Promise<FundResult>;
     /**
-     * Get credit score for an agent
-     * Backend endpoint: GET /credit/score/:agentId
+     * Fetch USDC borrow markets on Base from Morpho API.
+     * Caches results for 5 minutes.
      */
-    getCreditScore(agentId: bigint): Promise<{
-        agentId: string;
-        creditScore: number;
-        bayesianScore: number;
-        confidence: number;
-    }>;
+    getMarkets(forceRefresh?: boolean): Promise<MorphoMarketInfo[]>;
     /**
-     * Preview scored limit for an agent
-     * Backend endpoint: GET /credit/preview/:agentId
+     * Get MarketParams for a collateral token.
+     * Tries cache → API → on-chain idToMarketParams.
      */
-    previewScoredLimit(agentId: bigint): Promise<{
-        limit: string;
-        score: string;
-        eligible: boolean;
-    }>;
+    findMarketForCollateral(collateralSymbolOrAddress: string): Promise<MorphoMarketParams>;
+    /** Read MarketParams on-chain by market ID (bytes32). */
+    getMarketParams(marketId: string): Promise<MorphoMarketParams>;
+    /** Read on-chain position for a specific market. */
+    getPosition(marketId: string): Promise<MorphoPosition>;
     /**
-     * Get credit line info for an agent
-     * Backend endpoint: GET /credit/agent/:agentId
+     * Full status: positions across all discovered markets.
      */
-    getAgentCredit(agentId: bigint): Promise<{
-        agentId: string;
-        account: string;
-        creditInfo: Record<string, unknown>;
-        creditLine: Record<string, unknown>;
-    }>;
+    getStatus(): Promise<StatusResult>;
     /**
-     * Get protocol info
-     * Backend endpoint: GET /credit/protocol-info
+     * Deposit collateral into Morpho Blue.
+     *
+     * Flow:
+     * 1. EOA transfers collateral to AgentAccount
+     * 2. AgentAccount.executeBatch:
+     *    [collateral.approve(MorphoBlue), Morpho.supplyCollateral(params)]
      */
-    getProtocolInfo(): Promise<{
-        dailyDrawLimit: string;
-        totalBorrowed: string;
-        asset: string;
-    }>;
+    supplyCollateral(tokenSymbol: string, amount: string, marketParams?: MorphoMarketParams): Promise<DepositResult>;
     /**
-     * Get backend service status
-     * Backend endpoint: GET /status
+     * Borrow USDC against existing collateral.
+     *
+     * AgentAccount.execute: Morpho.borrow(params, amount, 0, account, account)
+     *
+     * @param usdcAmount - USDC amount (e.g. '100')
+     * @param tokenSymbol - collateral symbol to identify which market (default: first with collateral)
      */
-    getStatus(): Promise<{
-        status: string;
-        version: string;
-        signer: string;
-        contracts: {
-            healthy: boolean;
-        };
-    }>;
+    borrow(usdcAmount: string, tokenSymbol?: string, marketParams?: MorphoMarketParams): Promise<BorrowResult>;
     /**
-     * Get full OCCR score explanation with subscores, decay, and loan positions
-     * Backend endpoint: GET /agents/:agentId/score-explanation
+     * Deposit collateral AND borrow USDC in one batched transaction.
+     *
+     * AgentAccount.executeBatch:
+     *   [collateral.approve, Morpho.supplyCollateral, Morpho.borrow]
+     *
+     * The collateral must be transferred to AgentAccount first.
      */
-    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);
+    depositAndBorrow(tokenSymbol: string, collateralAmount: string, borrowUsdcAmount: string, marketParams?: MorphoMarketParams): Promise<DepositAndBorrowResult>;
     /**
-     * Deposit assets to vault
+     * Repay borrowed USDC from AgentAccount.
+     *
+     * AgentAccount.executeBatch:
+     *   [USDC.approve(MorphoBlue), Morpho.repay(params)]
      */
-    deposit(amount: bigint): Promise<TransactionResult>;
+    repay(usdcAmount: string, tokenSymbol?: string, marketParams?: MorphoMarketParams): Promise<RepayResult>;
     /**
-     * Withdraw assets from vault
+     * Withdraw collateral from Morpho Blue.
+     *
+     * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
+     *
+     * @param receiver - defaults to EOA wallet
      */
-    withdraw(amount: bigint): Promise<TransactionResult>;
+    withdrawCollateral(tokenSymbol: string, amount: string, marketParams?: MorphoMarketParams, receiver?: string): Promise<WithdrawResult>;
     /**
-     * Redeem shares for assets
+     * Sponsor: transfer collateral to another agent's AgentAccount.
+     * (The agent must then supplyCollateral themselves via their own account.)
      */
-    redeem(shares: bigint): Promise<TransactionResult>;
+    sponsor(target: {
+        agentId?: string;
+        address?: string;
+    }, tokenSymbol: string, amount: string): Promise<{
+        tx: string;
+        targetAccount: string;
+        targetAgentId?: string;
+    }>;
+    getCreditScore(): Promise<bigint>;
+    getAttestation(): Promise<ScoreAttestation>;
+    isEligible(minScore?: bigint): Promise<{
+        eligible: boolean;
+        currentScore: bigint;
+    }>;
+    isScoreFresh(): Promise<{
+        fresh: boolean;
+        age: bigint;
+    }>;
     /**
-     * Get vault statistics
+     * Execute a single call via AgentAccount.execute.
      */
-    getStats(): Promise<VaultStats>;
+    private exec;
     /**
-     * Get LP position
+     * Execute multiple calls via AgentAccount.executeBatch.
      */
-    getPosition(address?: string): Promise<LPPosition>;
+    private batch;
+    /** Convert MorphoMarketParams to Solidity tuple. */
+    private _toTuple;
+    /** Find the first market where the agent has collateral deposited. */
+    private _findActiveMarket;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * ScoringClient — Client for the Agether backend scoring API
+ *
+ * Endpoints:
+ *   GET  /score/:agentId          — x402-gated, compute + submit score on-chain
+ *   GET  /score/:agentId/current  — free, read current on-chain score
+ *   GET  /health                  — service health
+ *   GET  /status                  — detailed status
+ *   GET  /agents/:agentId/details — agent details
+ */
+
+interface ScoringClientConfig {
+    /** Backend base URL (e.g. http://95.179.189.214:3001) */
+    endpoint: string;
+    /** x402 config for paid scoring calls (optional — if not set, paid calls will fail) */
+    x402?: X402Config;
+}
+declare class ScoringClient {
+    private client;
+    private x402Client?;
+    private endpoint;
+    constructor(config: ScoringClientConfig);
     /**
-     * Preview deposit (how many shares for assets)
+     * Request a fresh score computation.
+     *
+     * This is x402-gated: the backend returns 402, the X402Client
+     * signs an EIP-3009 payment, and the backend computes + submits
+     * the score on-chain via AgentReputation.submitScore().
+     *
+     * Returns the ScoreResult with breakdown and txHash.
      */
-    previewDeposit(assets: bigint): Promise<bigint>;
+    requestScore(agentId: string | bigint): Promise<ScoreResult>;
     /**
-     * Preview withdraw (how many assets for shares)
+     * Get the current on-chain score (free, no payment required).
      */
-    previewRedeem(shares: bigint): Promise<bigint>;
+    getCurrentScore(agentId: string | bigint): Promise<{
+        agentId: string;
+        score: number;
+        timestamp: number;
+        signer: string;
+        fresh: boolean;
+        age: number;
+    }>;
     /**
-     * Check if withdrawal is allowed (sufficient liquidity)
+     * Get detailed agent info from backend.
      */
-    canWithdraw(assets: bigint): Promise<boolean>;
+    getAgentDetails(agentId: string | bigint): Promise<{
+        agentId: string;
+        owner: string;
+        account: string;
+        accountExists: boolean;
+        kyaApproved: boolean;
+        score: number;
+        scoreFresh: boolean;
+        eligible: boolean;
+    }>;
     /**
-     * Get current APY estimate
+     * Health check.
      */
-    estimateAPY(): Promise<number>;
-    private getAsset;
+    getHealth(): Promise<{
+        status: string;
+        timestamp: string;
+    }>;
     /**
-     * Get underlying asset address
+     * Detailed status (contracts, signer, chain).
      */
-    getAssetAddress(): Promise<string>;
+    getStatus(): Promise<{
+        status: string;
+        chain: {
+            id: number;
+            name: string;
+        };
+        contracts: Record<string, string>;
+        scoring: {
+            priceUsdc: string;
+            x402PayToAddress: string;
+        };
+        signer: string;
+    }>;
     /**
-     * Get vault share token address
+     * Agent count and list.
      */
-    getVaultAddress(): string;
+    getAgentCount(): Promise<{
+        totalAgents: number;
+        totalAccounts: number;
+    }>;
 }
 
 /**
@@ -703,423 +724,6 @@ declare class AgentIdentityClient {
     };
 }
 
-/**
- * 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;
-    /** Auto-borrow from Morpho credit line when USDC balance is insufficient for payment */
-    autoDraw?: boolean;
-    /** MorphoCredit contract address (required for autoDraw) */
-    morphoCreditAddress?: 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 static readonly MORPHO_DRAW_ABI;
-    private static readonly AGENT_ACCOUNT_EXEC_ABI;
-    private static readonly ERC20_BALANCE_ABI;
-    private static readonly AUTO_DRAW_COLLATERALS;
-    private ensureBalance;
-    private riskCheck;
-}
-
-/**
- * MorphoCreditClient — SDK client for Morpho-backed overcollateralized credit
- *
- * Full lifecycle for AI agents:
- *   - Register (ERC-8004 + AccountFactory)
- *   - Check balances and status
- *   - Deposit collateral + borrow USDC
- *   - Repay debt + withdraw collateral
- *   - Sponsor another agent
- *   - Fund AgentAccount
- */
-interface MorphoCreditConfig {
-    /** Private key for signing */
-    privateKey: string;
-    /** Base RPC URL */
-    rpcUrl: string;
-    /** Agent's ERC-8004 ID (optional — auto-resolved from chain if omitted) */
-    agentId?: string | bigint;
-    /** Contract addresses */
-    contracts: {
-        morphoCredit: string;
-        accountFactory: string;
-        usdc: string;
-        /** ERC-8004 identity registry (needed for register()) */
-        agentRegistry?: string;
-    };
-}
-interface CollateralToken {
-    symbol: string;
-    address: string;
-    decimals: number;
-}
-interface MorphoPosition {
-    token: string;
-    collateralAmount: bigint;
-    borrowedAmount: bigint;
-    borrowShares: bigint;
-    isActive: boolean;
-}
-interface DepositResult {
-    tx: string;
-    amount: bigint;
-    token: string;
-    agentAccount: string;
-    totalCollateral: bigint;
-}
-interface BorrowResult {
-    tx: string;
-    amount: bigint;
-    agentAccount: string;
-    totalDebt: bigint;
-    collateralToken: string;
-}
-interface DepositAndBorrowResult {
-    depositTx: string;
-    borrowTx: string;
-    collateral: {
-        amount: bigint;
-        token: string;
-    };
-    borrowed: bigint;
-    agentAccount: string;
-    totalDebt: bigint;
-}
-interface SponsorResult {
-    depositTx: string;
-    borrowTx?: string;
-    targetAccount: string;
-    targetAgentId?: string;
-    collateral: {
-        amount: bigint;
-        token: string;
-    };
-    borrowed?: bigint;
-    totalCollateral: bigint;
-    totalDebt: bigint;
-}
-interface RepayResult {
-    tx: string;
-    amount: bigint;
-    remainingDebt: bigint;
-}
-interface WithdrawResult {
-    tx: string;
-    amount: bigint;
-    token: string;
-    destination: string;
-    remainingCollateral: bigint;
-}
-interface RegisterResult {
-    tx: string;
-    agentId: string;
-    address: string;
-    agentAccount: string;
-    alreadyRegistered: boolean;
-}
-interface BalancesResult {
-    address: string;
-    agentId: string;
-    eth: string;
-    usdc: string;
-    agentAccount?: {
-        address: string;
-        eth: string;
-        usdc: string;
-    };
-}
-interface StatusResult {
-    agentAccount: string;
-    totalDebt: string;
-    positions: Array<{
-        token: string;
-        collateral: string;
-        debt: string;
-        active: boolean;
-    }>;
-}
-interface FundResult {
-    tx: string;
-    amount: string;
-    agentAccount: string;
-}
-interface LtvCheckResult {
-    ok: boolean;
-    currentLtv: number;
-    newLtv: number;
-    maxLtv: number;
-    collateralUsd: number;
-    currentDebt: number;
-    maxBorrow: number;
-    message?: string;
-}
-declare class MorphoCreditClient {
-    private signer;
-    private config;
-    private morpho;
-    private factory;
-    private accountAddress?;
-    private resolvedAgentId?;
-    private collaterals;
-    private static readonly ERC8004_ABI;
-    constructor(config: MorphoCreditConfig, collaterals?: Record<string, CollateralToken>);
-    private resolveToken;
-    /**
-     * Resolve agentId — from config, cache, or on-chain lookup.
-     */
-    getAgentId(): Promise<string>;
-    /**
-     * Get the AgentAccount address for the configured agentId.
-     */
-    getAccountAddress(): Promise<string>;
-    /**
-     * Get the AgentAccount address for any agentId.
-     */
-    getAccountForAgent(agentId: string | bigint): Promise<string>;
-    private ensureCreditProvider;
-    /**
-     * Approve ERC-20 token from EOA → MorphoCredit, then deposit for account.
-     * This is 2 EOA txs (approve + depositCollateralFor) — cannot be batched
-     * because both are called from EOA, not from AgentAccount.
-     */
-    private approveAndDeposit;
-    private morphoIface;
-    private erc20Iface;
-    /**
-     * Execute multiple calls via AgentAccount.executeBatch() in a single tx.
-     * Each call is { target, value, data }.
-     */
-    private batch;
-    /**
-     * Register a new ERC-8004 agent identity and create an AgentAccount.
-     * If already registered (agentId in config or on-chain), returns existing info.
-     *
-     * @param name - Agent display name
-     */
-    register(name: string): Promise<RegisterResult>;
-    /**
-     * Get ETH and USDC balances for EOA wallet and AgentAccount.
-     */
-    getBalances(): Promise<BalancesResult>;
-    /**
-     * Get full Morpho credit status — all positions + total debt.
-     */
-    getStatus(): Promise<StatusResult>;
-    /**
-     * Transfer USDC from EOA wallet into AgentAccount.
-     *
-     * @param amount - Human-readable USDC amount (e.g. "50")
-     */
-    fundAccount(amount: string): Promise<FundResult>;
-    private static readonly ORACLE_ABI;
-    /**
-     * Check whether a borrow would exceed max LTV.
-     * Call before borrow() or depositAndBorrow() to get a clear error instead of on-chain revert.
-     *
-     * @param tokenSymbol - Collateral token
-     * @param additionalCollateral - Additional collateral being deposited ("0" if just borrowing)
-     * @param borrowAmount - USDC to borrow
-     */
-    checkLtv(tokenSymbol: string, additionalCollateral: string, borrowAmount: string): Promise<LtvCheckResult>;
-    /**
-     * Deposit collateral from EOA into Morpho for own AgentAccount.
-     * Does NOT borrow — use `borrow()` or `depositAndBorrow()` for that.
-     *
-     * @param tokenSymbol - Collateral token (WETH, wstETH, cbETH)
-     * @param amount - Human-readable amount (e.g. "0.05")
-     */
-    deposit(tokenSymbol: string, amount: string): Promise<DepositResult>;
-    /**
-     * Deposit collateral AND borrow USDC in a single SDK call.
-     * USDC lands in the AgentAccount.
-     *
-     * @param tokenSymbol - Collateral token (WETH, wstETH, cbETH)
-     * @param collateralAmount - Human-readable collateral amount (e.g. "0.05")
-     * @param borrowAmount - Human-readable USDC amount to borrow (e.g. "50")
-     */
-    depositAndBorrow(tokenSymbol: string, collateralAmount: string, borrowAmount: string): Promise<DepositAndBorrowResult>;
-    /**
-     * Borrow USDC against already-deposited collateral.
-     * Auto-detects which collateral token has a position.
-     * USDC lands in AgentAccount — ready for x402 payments.
-     *
-     * @param amount - Human-readable USDC amount (e.g. "100")
-     */
-    borrow(amount: string): Promise<BorrowResult>;
-    /**
-     * Deposit collateral for another agent. Caller pays from their wallet.
-     * Optionally borrow USDC for the agent (only works if caller owns the AgentAccount).
-     *
-     * Supports both agentId lookup and direct address.
-     *
-     * @param target - `{ agentId: "17676" }` or `{ address: "0x..." }`
-     * @param tokenSymbol - Collateral token
-     * @param amount - Human-readable collateral amount
-     * @param borrowAmount - Optional: USDC to borrow (only if caller is owner)
-     */
-    sponsor(target: {
-        agentId: string | bigint;
-    } | {
-        address: string;
-    }, tokenSymbol: string, amount: string, borrowAmount?: string): Promise<SponsorResult>;
-    /**
-     * Repay borrowed USDC from AgentAccount back to Morpho.
-     *
-     * @param amount - Human-readable USDC amount (e.g. "50")
-     */
-    repay(amount: string): Promise<RepayResult>;
-    /**
-     * Withdraw collateral from Morpho back to EOA.
-     *
-     * @param tokenSymbol - Collateral token
-     * @param amount - Human-readable amount or "all"
-     */
-    withdraw(tokenSymbol: string, amount: string): Promise<WithdrawResult>;
-    /**
-     * Get position for a specific collateral token.
-     */
-    getPosition(tokenSymbol: string): Promise<MorphoPosition>;
-    /**
-     * Get all active positions across all collateral tokens.
-     */
-    getAllPositions(): Promise<MorphoPosition[]>;
-    /**
-     * Get total debt across all positions.
-     */
-    getTotalDebt(): Promise<bigint>;
-    /**
-     * Get USDC balance in the AgentAccount.
-     */
-    getAccountUSDC(): Promise<bigint>;
-    /** Get the wallet (signer) address */
-    getAddress(): string;
-}
-
-/**
- * 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
  */
@@ -1165,15 +769,32 @@ declare function bpsToRate(bps: bigint): number;
 declare function rateToBps(rate: number): bigint;
 
 /**
- * Network configurations (v2)
+ * Contract ABIs (minimal for SDK)
+ *
+ * Architecture:
+ * - AccountFactory + AgentAccount (KYA-gated smart wallets)
+ * - AgentReputation (oracle-based credit scores)
+ * - ValidationRegistry (KYA code validation)
+ * - ERC-8004 IdentityRegistry
+ * - Morpho Blue (direct overcollateralized lending)
+ */
+declare const IDENTITY_REGISTRY_ABI: string[];
+declare const ACCOUNT_FACTORY_ABI: string[];
+declare const AGENT_ACCOUNT_ABI: string[];
+declare const AGENT_REPUTATION_ABI: string[];
+declare const VALIDATION_REGISTRY_ABI: string[];
+declare const MORPHO_BLUE_ABI: string[];
+declare const ERC20_ABI: string[];
+
+/**
+ * Network configurations
  *
- * v2 contract architecture:
- * - AccountFactory + AgentAccount (smart wallets)
- * - ReputationCredit (ICreditProvider, undercollateralized)
- * - LPVault (ERC-4626)
- * - ValidationRegistry (KYA)
- * - AgentReputation (Bayesian scoring)
+ * Contract architecture:
+ * - AccountFactory + AgentAccount (KYA-gated smart wallets)
+ * - AgentReputation (oracle-based scoring)
+ * - ValidationRegistry (KYA code validation)
  * - ERC-8004 IdentityRegistry
+ * - Morpho Blue (direct overcollateralized lending)
  *
  * All contract addresses are baked in — agents only need to specify chainId.
  */
@@ -1186,31 +807,5 @@ 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 MORPHO_CREDIT_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 BalancesResult, type BayesianScore, type BorrowResult, CREDIT_PROVIDER_ABI, ChainId, type CollateralToken, type ContractAddresses, type CreditApplication, type CreditAppliedEvent, type CreditApprovedEvent, type CreditDrawnEvent, type CreditInfo, type CreditLine, CreditNotActiveError, type CreditRejectedEvent, type CreditRepaidEvent, CreditStatus, type DepositAndBorrowResult, type DepositResult, type DrawRequest, ERC20_ABI, type FundResult, type GraduationStatus, IDENTITY_REGISTRY_ABI, InsufficientCreditError, type LPPosition, LP_VAULT_ABI, type LoanPosition, type LtvCheckResult, MORPHO_CREDIT_ABI, MorphoCreditClient, type MorphoCreditConfig, type MorphoMarketParams, type MorphoPosition, type PaymentProof, type PaymentRequirements, type ProviderStatus, REPUTATION_CREDIT_ABI, type RegisterResult, type RepayRequest, type RepayResult, type RiskCheckResponse, type RiskFactor, type ScoreExplanation, type ScoredLimitPreview, ScoringClient, type ScoringContext, ScoringRejectedError, type ScoringRequest, type ScoringResult, type SponsorResult, type StatusResult, type TransactionResult, VALIDATION_REGISTRY_ABI, VaultClient, type VaultClientOptions, type VaultStats, WalletClient, type WalletClientConfig, type WalletInfo, type WithdrawResult, X402Client, type X402Config, type X402PaymentRequest, type X402PaymentResult, type X402Response, bpsToRate, createConfig, formatAPR, formatAddress, formatHealthFactor, formatPercent, formatTimestamp, formatUSD, formatUnits, getDefaultConfig, getUSDCAddress, parseUnits, rateToBps };
+export { ACCOUNT_FACTORY_ABI, AGENT_ACCOUNT_ABI, AGENT_REPUTATION_ABI, AgentIdentityClient, type AgentIdentityClientOptions, AgentNotApprovedError, AgetherClient, type AgetherClientOptions, type AgetherConfig, AgetherError, type BalancesResult, type BorrowResult, ChainId, type ContractAddresses, type DepositAndBorrowResult, type DepositResult, ERC20_ABI, type FundResult, IDENTITY_REGISTRY_ABI, InsufficientBalanceError, MORPHO_BLUE_ABI, MorphoClient, type MorphoClientConfig, type MorphoMarketInfo, type MorphoMarketParams, type MorphoPosition, type PaymentRequirements, type PositionResult, type RegisterResult, type RepayResult, type ScoreAttestation, type ScoreResult, ScoringClient, type ScoringClientConfig, ScoringRejectedError, type StatusResult, type TransactionResult, VALIDATION_REGISTRY_ABI, type WithdrawResult, X402Client, type X402Config, type X402PaymentRequest, type X402PaymentResult, type X402Response, bpsToRate, createConfig, formatAPR, formatAddress, formatHealthFactor, formatPercent, formatTimestamp, formatUSD, formatUnits, getDefaultConfig, parseUnits, rateToBps };