@keelcodes/sdk 0.0.0-stage → 2.0.0

package/dist/account.d.ts

@@ -0,0 +1,50 @@
+import { HttpClient } from './http';
+import type { KeelModule } from './types';
+export interface TenantCreateParams {
+    name: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TenantResult {
+    tenantId: string;
+    name: string;
+    apiKey: string;
+}
+export interface ApikeyCreateParams {
+    tenantId: string;
+    module: KeelModule;
+    /** 幂等键（同 reference 不重复签发）。 */
+    reference?: string;
+}
+export interface ApikeyResult {
+    apiKey: string;
+    module: KeelModule;
+}
+export interface SubscriptionParams {
+    module: KeelModule;
+    planId: string;
+    /** 幂等键（同 reference 不重复订阅）。 */
+    reference?: string;
+}
+export interface SubscriptionResult {
+    module: KeelModule;
+    planId: string;
+    status: string;
+}
+export declare class AccountAPI {
+    private http;
+    constructor(http: HttpClient);
+    tenant: {
+        create: (p: TenantCreateParams) => Promise<TenantResult>;
+        get: (tenantId: string) => Promise<TenantResult>;
+    };
+    /** 按模块签发 key（用户订阅哪个模块，就为哪个模块签发）。 */
+    apikey: {
+        create: (p: ApikeyCreateParams) => Promise<ApikeyResult>;
+        revoke: (apiKey: string) => Promise<unknown>;
+    };
+    subscription: {
+        get: (module: KeelModule) => Promise<SubscriptionResult>;
+        subscribe: (p: SubscriptionParams) => Promise<SubscriptionResult>;
+        cancel: (module: KeelModule) => Promise<unknown>;
+    };
+}

package/dist/account.js

@@ -0,0 +1,26 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// @keelcodes/sdk — account 模块（3 动作）
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountAPI = void 0;
+class AccountAPI {
+    constructor(http) {
+        this.http = http;
+        this.tenant = {
+            create: (p) => this.http.post('/v1/account/tenant', p),
+            get: (tenantId) => this.http.get('/v1/account/tenant/' + encodeURIComponent(tenantId)),
+        };
+        /** 按模块签发 key（用户订阅哪个模块，就为哪个模块签发）。 */
+        this.apikey = {
+            create: (p) => this.http.post('/v1/account/apikey', p),
+            revoke: (apiKey) => this.http.post('/v1/account/apikey/revoke', { apiKey }),
+        };
+        this.subscription = {
+            get: (module) => this.http.get('/v1/account/subscription?module=' + module),
+            subscribe: (p) => this.http.post('/v1/account/subscription', p),
+            cancel: (module) => this.http.post('/v1/account/subscription/cancel', { module }),
+        };
+    }
+}
+exports.AccountAPI = AccountAPI;

package/dist/data.d.ts

@@ -0,0 +1,217 @@
+import { HttpClient } from './http';
+export interface BarsParams {
+    symbol: string;
+    timeframe?: string;
+    marketType?: 'spot' | 'swap';
+    start?: number;
+    end?: number;
+    limit?: number;
+}
+export interface BarsResult {
+    symbol: string;
+    bars: Record<string, unknown>[];
+}
+export interface TickersParams {
+    symbols: string | string[];
+    marketType?: 'spot' | 'swap';
+}
+export interface TickersResult {
+    items: Record<string, unknown>[];
+    missing: string[];
+}
+export interface FactorsParams {
+    symbols?: string;
+    category?: string;
+}
+export interface FactorsResult {
+    factors: Record<string, unknown>;
+    values: Record<string, Record<string, number>>;
+}
+export interface GraphParams {
+    symbol?: string;
+    entity?: string;
+}
+export interface GraphResult {
+    entities: unknown[];
+    edges: unknown[];
+}
+export interface PredictParams {
+    model: 'bolt' | 'moirai' | 'timesfm';
+    symbol: string;
+    start?: number;
+    end?: number;
+    limit?: number;
+}
+export interface PredictResult {
+    predictions: unknown[];
+}
+export interface EventsParams {
+    chain?: string;
+    address?: string;
+    contract?: string;
+    eventType?: string;
+    category?: string;
+    fromBlock?: string;
+    toBlock?: string;
+    limit?: number;
+}
+export interface EventsResult {
+    events: unknown[];
+}
+export interface RagParams {
+    query: string;
+    topK?: number;
+}
+export interface RagResult {
+    results: unknown[];
+}
+export declare class DataAPI {
+    private http;
+    constructor(http: HttpClient);
+    bars(params: BarsParams): Promise<BarsResult>;
+    tickers(params: TickersParams): Promise<TickersResult>;
+    factors(params?: FactorsParams): Promise<FactorsResult>;
+    graph(params?: GraphParams): Promise<GraphResult>;
+    predictions(params: PredictParams): Promise<PredictResult>;
+    events(params?: EventsParams): Promise<EventsResult>;
+    rag(params: RagParams): Promise<RagResult>;
+    /** 取单符号最新行情（ticker）。 */
+    ticker(symbol: string): Promise<Record<string, unknown>>;
+    /** 列出受支持交易符号（可按市场 / 关键词过滤）。 */
+    symbols(params?: {
+        market?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /** 模糊搜索符号（跨市场）。 */
+    symbolSearch(p: {
+        keyword: string;
+        market?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /** 解析原始符号关键词为规范交易符号。 */
+    symbolResolve(p: {
+        symbol: string;
+        market?: string;
+    }): Promise<Record<string, unknown>>;
+    /** 券商市场策略（各市场主交易场所）。 */
+    brokerPolicy(): Promise<Record<string, unknown>>;
+    /** 取因子历史序列（按符号 + 因子 id + 时间窗）。 */
+    factorsHistory(p: {
+        symbol: string;
+        factor: string;
+        start?: number;
+        end?: number;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /** 取快照数据（macro / onchain / defi_tvl / indices…）。 */
+    snapshots(p?: {
+        type?: string;
+        date?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /** DC 统计（事件总数 / 活跃链）。 */
+    stats(): Promise<Record<string, unknown>>;
+    /** 各链区块索引检查点。 */
+    checkpoints(chain?: string): Promise<Record<string, unknown>>;
+    /** DC 订阅套餐价目（公开）。 */
+    plans(): Promise<Record<string, unknown>>;
+    /** 支持的代币列表（含元数据）。 */
+    tokens(chain?: string): Promise<Record<string, unknown>>;
+    /** 支持的区块链网络列表。 */
+    chains(): Promise<Record<string, unknown>>;
+    /** 事件业务分类目录（category_id + label_id）。 */
+    eventCategories(): Promise<Record<string, unknown>>;
+    /** 按业务分类聚合的事件计数（可按链过滤）。 */
+    eventStats(chain?: string): Promise<Record<string, unknown>>;
+    /** 订阅 DC 套餐（x-wallet-address 鉴权；免费即时生效返 dcApiKey，付费返支付意图）。 */
+    subscriptionSubscribe(p: {
+        planId: string;
+        rail?: string;
+        walletAddress: string;
+    }): Promise<Record<string, unknown>>;
+    /** 轮询 DC 订阅支付状态（x-wallet-address 鉴权）。 */
+    subscriptionPaymentCheck(walletAddress: string): Promise<Record<string, unknown>>;
+    /** 确认 DC 订阅的 x402 支付（提交 txHash；付款钱包须匹配）。 */
+    subscriptionVerify(p: {
+        txHash: string;
+        walletAddress: string;
+    }): Promise<Record<string, unknown>>;
+    /** 读取 DC 订阅用量（套餐 / key / 月配额 / 当前用量 / 日明细）。 */
+    subscriptionUsage(walletAddress: string): Promise<Record<string, unknown>>;
+    market: {
+        /** 按名称/符号搜索 DEX 代币（DexScreener）。 */
+        search: (p: {
+            keyword: string;
+            chainIndex?: string;
+            limit?: string;
+        }) => Promise<unknown>;
+        /** 热门 DEX 池（GeckoTerminal trending）。 */
+        hot: (p?: {
+            chainIndex?: string;
+            limit?: string;
+        }) => Promise<unknown>;
+        /** K 线（OHLCV）。 */
+        candles: (p: {
+            chainIndex: string;
+            tokenAddress: string;
+            period?: string;
+            limit?: string;
+        }) => Promise<unknown>;
+        /** 实时 DEX 价。 */
+        price: (p: {
+            chainIndex: string;
+            tokenAddress: string;
+        }) => Promise<unknown>;
+        /** 加入监控列表（自动采集 K 线 / 快照）。 */
+        trackToken: (p: {
+            chain: string;
+            tokenAddress: string;
+            label?: string;
+        }) => Promise<unknown>;
+        /** 列出监控中的代币。 */
+        listTracked: (chain?: string) => Promise<unknown>;
+        /** 注册自定义事件签名（topicHash + eventType，可选 ABI）。 */
+        registerEvent: (p: {
+            chain: string;
+            topicHash: string;
+            eventType: string;
+            eventName?: string;
+            abi?: unknown;
+        }) => Promise<unknown>;
+        /** Market 订阅套餐价目（公开）。 */
+        subscriptionPlans: () => Promise<unknown>;
+        /** 发起 Market 订阅支付（免费即时生效；付费返支付意图）。 */
+        subscriptionCheckout: (p: {
+            plan_id: string;
+            rail?: string;
+            subscriber?: string;
+        }) => Promise<unknown>;
+        /** 轮询 Market 订阅支付状态。 */
+        subscriptionPaymentCheck: (p?: {
+            subscriber?: string;
+        }) => Promise<unknown>;
+        /** 确认 Market 订阅的 x402 支付（提交 txHash）。 */
+        subscriptionVerify: (p: {
+            txHash: string;
+        }) => Promise<unknown>;
+        /** 读取 Market 订阅用量。 */
+        subscriptionUsage: () => Promise<unknown>;
+    };
+    factorFactory: {
+        /** 创建因子挖掘任务（结构化 preferences/constraints/formulas；intent 走 LLM 解析）。返回 job_id。 */
+        start: (p?: {
+            preferences?: Record<string, unknown>;
+            constraints?: Record<string, unknown>;
+            formulas?: string[];
+            intent?: string;
+        }) => Promise<unknown>;
+        /** 查询挖掘任务状态（含 stage 细分：pool/eval/select/persist）。 */
+        status: (jobId: string) => Promise<unknown>;
+        /** 查询挖掘任务结果（合格因子列表 + 统计）。 */
+        result: (jobId: string) => Promise<unknown>;
+        /** 最近挖掘任务列表。 */
+        list: (limit?: number) => Promise<unknown>;
+        /** 取消挖掘任务（排队/运行中可取消）。 */
+        cancel: (jobId: string) => Promise<unknown>;
+    };
+}

package/dist/data.js

@@ -0,0 +1,253 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// @keelcodes/sdk — data 模块（7 动作）
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataAPI = void 0;
+class DataAPI {
+    constructor(http) {
+        this.http = http;
+        // ── Market 子域（DEX 行情 / 监控 / 订阅）：canonical `/v1/data/market*` ──
+        this.market = {
+            /** 按名称/符号搜索 DEX 代币（DexScreener）。 */
+            search: (p) => {
+                const q = new URLSearchParams({ keyword: p.keyword });
+                if (p.chainIndex)
+                    q.set('chainIndex', p.chainIndex);
+                if (p.limit)
+                    q.set('limit', p.limit);
+                return this.http.get('/v1/data/market/token-search?' + q.toString());
+            },
+            /** 热门 DEX 池（GeckoTerminal trending）。 */
+            hot: (p = {}) => {
+                const q = new URLSearchParams();
+                if (p.chainIndex)
+                    q.set('chainIndex', p.chainIndex);
+                if (p.limit)
+                    q.set('limit', p.limit);
+                return this.http.get('/v1/data/market/hot-tokens?' + q.toString());
+            },
+            /** K 线（OHLCV）。 */
+            candles: (p) => {
+                const q = new URLSearchParams({ chainIndex: p.chainIndex, tokenAddress: p.tokenAddress });
+                if (p.period)
+                    q.set('period', p.period);
+                if (p.limit)
+                    q.set('limit', p.limit);
+                return this.http.get('/v1/data/market/candles?' + q.toString());
+            },
+            /** 实时 DEX 价。 */
+            price: (p) => this.http.get('/v1/data/market/price?' + new URLSearchParams({ chainIndex: p.chainIndex, tokenAddress: p.tokenAddress }).toString()),
+            /** 加入监控列表（自动采集 K 线 / 快照）。 */
+            trackToken: (p) => this.http.post('/v1/data/market/tracked-tokens', p),
+            /** 列出监控中的代币。 */
+            listTracked: (chain) => this.http.get('/v1/data/market/tracked-tokens' + (chain ? '?chain=' + encodeURIComponent(chain) : '')),
+            /** 注册自定义事件签名（topicHash + eventType，可选 ABI）。 */
+            registerEvent: (p) => this.http.post('/v1/data/market/custom-sigs', p),
+            /** Market 订阅套餐价目（公开）。 */
+            subscriptionPlans: () => this.http.get('/v1/data/market-subscription/plans'),
+            /** 发起 Market 订阅支付（免费即时生效；付费返支付意图）。 */
+            subscriptionCheckout: (p) => this.http.post('/v1/data/market-subscription/checkout', p),
+            /** 轮询 Market 订阅支付状态。 */
+            subscriptionPaymentCheck: (p = {}) => this.http.post('/v1/data/market-subscription/payment-check', p),
+            /** 确认 Market 订阅的 x402 支付（提交 txHash）。 */
+            subscriptionVerify: (p) => this.http.post('/v1/data/market-subscription/verify', p),
+            /** 读取 Market 订阅用量。 */
+            subscriptionUsage: () => this.http.get('/v1/data/market-subscription/usage'),
+        };
+        // ── Factor 工厂（因子挖掘）：canonical `/v1/data/factor-factory/*`（由 ml-service 承载）──
+        this.factorFactory = {
+            /** 创建因子挖掘任务（结构化 preferences/constraints/formulas；intent 走 LLM 解析）。返回 job_id。 */
+            start: (p = {}) => {
+                const body = { preferences: p.preferences ?? {}, constraints: p.constraints ?? {} };
+                if (p.formulas?.length)
+                    body.formulas = p.formulas;
+                return p.intent
+                    ? this.http.post('/v1/data/factor-factory/mine', { ...body, intent: p.intent })
+                    : this.http.post('/v1/data/factor-factory/start', body);
+            },
+            /** 查询挖掘任务状态（含 stage 细分：pool/eval/select/persist）。 */
+            status: (jobId) => this.http.get('/v1/data/factor-factory/status?job_id=' + encodeURIComponent(jobId)),
+            /** 查询挖掘任务结果（合格因子列表 + 统计）。 */
+            result: (jobId) => this.http.get('/v1/data/factor-factory/result?job_id=' + encodeURIComponent(jobId)),
+            /** 最近挖掘任务列表。 */
+            list: (limit) => this.http.get('/v1/data/factor-factory/list' + (limit ? '?limit=' + limit : '')),
+            /** 取消挖掘任务（排队/运行中可取消）。 */
+            cancel: (jobId) => this.http.post('/v1/data/factor-factory/cancel?job_id=' + encodeURIComponent(jobId)),
+        };
+    }
+    bars(params) {
+        const q = new URLSearchParams({ symbol: params.symbol });
+        if (params.timeframe)
+            q.set('timeframe', params.timeframe);
+        if (params.marketType)
+            q.set('market_type', params.marketType);
+        if (params.start)
+            q.set('start', String(params.start));
+        if (params.end)
+            q.set('end', String(params.end));
+        if (params.limit)
+            q.set('limit', String(params.limit));
+        return this.http.get('/v1/data/bars?' + q.toString());
+    }
+    tickers(params) {
+        const symbols = Array.isArray(params.symbols) ? params.symbols.join(',') : params.symbols;
+        const q = new URLSearchParams({ symbols });
+        if (params.marketType)
+            q.set('market_type', params.marketType);
+        return this.http.get('/v1/data/tickers?' + q.toString());
+    }
+    factors(params = {}) {
+        const q = new URLSearchParams();
+        if (params.symbols)
+            q.set('symbols', params.symbols);
+        if (params.category)
+            q.set('category', params.category);
+        return this.http.get('/v1/data/factors?' + q.toString());
+    }
+    graph(params = {}) {
+        const q = new URLSearchParams();
+        if (params.symbol)
+            q.set('symbol', params.symbol);
+        if (params.entity)
+            q.set('entity', params.entity);
+        return this.http.get('/v1/data/graph?' + q.toString());
+    }
+    predictions(params) {
+        const q = new URLSearchParams({ model: params.model, symbol: params.symbol });
+        if (params.start)
+            q.set('start', String(params.start));
+        if (params.end)
+            q.set('end', String(params.end));
+        if (params.limit)
+            q.set('limit', String(params.limit));
+        return this.http.get('/v1/data/predictions?' + q.toString());
+    }
+    events(params = {}) {
+        const q = new URLSearchParams();
+        if (params.chain)
+            q.set('chain', params.chain);
+        if (params.address)
+            q.set('address', params.address);
+        if (params.contract)
+            q.set('contract', params.contract);
+        if (params.eventType)
+            q.set('event_type', params.eventType);
+        if (params.category)
+            q.set('category', params.category);
+        if (params.fromBlock)
+            q.set('from_block', params.fromBlock);
+        if (params.toBlock)
+            q.set('to_block', params.toBlock);
+        if (params.limit)
+            q.set('limit', String(params.limit));
+        return this.http.get('/v1/data/events?' + q.toString());
+    }
+    rag(params) {
+        return this.http.post('/v1/data/rag', params);
+    }
+    // ── 行情 / 符号 / 快照（旧 hub MCP 能力）──
+    /** 取单符号最新行情（ticker）。 */
+    ticker(symbol) {
+        return this.http.get('/v1/data/ticker?symbol=' + encodeURIComponent(symbol));
+    }
+    /** 列出受支持交易符号（可按市场 / 关键词过滤）。 */
+    symbols(params = {}) {
+        const q = new URLSearchParams();
+        if (params.market)
+            q.set('market', params.market);
+        if (params.limit)
+            q.set('limit', String(params.limit));
+        const qs = q.toString();
+        return this.http.get('/v1/data/symbols' + (qs ? '?' + qs : ''));
+    }
+    /** 模糊搜索符号（跨市场）。 */
+    symbolSearch(p) {
+        const q = new URLSearchParams({ keyword: p.keyword });
+        if (p.market)
+            q.set('market', p.market);
+        if (p.limit)
+            q.set('limit', String(p.limit));
+        return this.http.get('/v1/data/symbols/search?' + q.toString());
+    }
+    /** 解析原始符号关键词为规范交易符号。 */
+    symbolResolve(p) {
+        const q = new URLSearchParams({ symbol: p.symbol });
+        if (p.market)
+            q.set('market', p.market);
+        return this.http.get('/v1/data/symbol/resolve?' + q.toString());
+    }
+    /** 券商市场策略（各市场主交易场所）。 */
+    brokerPolicy() {
+        return this.http.get('/v1/data/policy/broker-market');
+    }
+    /** 取因子历史序列（按符号 + 因子 id + 时间窗）。 */
+    factorsHistory(p) {
+        const q = new URLSearchParams({ symbol: p.symbol, factor: p.factor });
+        if (p.start)
+            q.set('start', String(p.start));
+        if (p.end)
+            q.set('end', String(p.end));
+        if (p.limit)
+            q.set('limit', String(p.limit));
+        return this.http.get('/v1/data/factors/history?' + q.toString());
+    }
+    /** 取快照数据（macro / onchain / defi_tvl / indices…）。 */
+    snapshots(p = {}) {
+        const q = new URLSearchParams();
+        if (p.type)
+            q.set('type', p.type);
+        if (p.date)
+            q.set('date', p.date);
+        if (p.limit)
+            q.set('limit', String(p.limit));
+        const qs = q.toString();
+        return this.http.get('/v1/data/snapshots' + (qs ? '?' + qs : ''));
+    }
+    // ── DC（数据中心）面：统计 / 链 / 代币 / 事件分类 / 订阅 ──
+    /** DC 统计（事件总数 / 活跃链）。 */
+    stats() {
+        return this.http.get('/v1/data/stats');
+    }
+    /** 各链区块索引检查点。 */
+    checkpoints(chain) {
+        return this.http.get('/v1/data/checkpoints' + (chain ? '?chain=' + encodeURIComponent(chain) : ''));
+    }
+    /** DC 订阅套餐价目（公开）。 */
+    plans() {
+        return this.http.get('/v1/data/plans');
+    }
+    /** 支持的代币列表（含元数据）。 */
+    tokens(chain) {
+        return this.http.get('/v1/data/tokens' + (chain ? '?chain=' + encodeURIComponent(chain) : ''));
+    }
+    /** 支持的区块链网络列表。 */
+    chains() {
+        return this.http.get('/v1/data/chains');
+    }
+    /** 事件业务分类目录（category_id + label_id）。 */
+    eventCategories() {
+        return this.http.get('/v1/data/event-categories');
+    }
+    /** 按业务分类聚合的事件计数（可按链过滤）。 */
+    eventStats(chain) {
+        return this.http.get('/v1/data/event-stats' + (chain ? '?chain=' + encodeURIComponent(chain) : ''));
+    }
+    /** 订阅 DC 套餐（x-wallet-address 鉴权；免费即时生效返 dcApiKey，付费返支付意图）。 */
+    subscriptionSubscribe(p) {
+        return this.http.post('/v1/data/subscribe', { planId: p.planId, rail: p.rail }, { 'x-wallet-address': p.walletAddress });
+    }
+    /** 轮询 DC 订阅支付状态（x-wallet-address 鉴权）。 */
+    subscriptionPaymentCheck(walletAddress) {
+        return this.http.post('/v1/data/payment-check', {}, { 'x-wallet-address': walletAddress });
+    }
+    /** 确认 DC 订阅的 x402 支付（提交 txHash；付款钱包须匹配）。 */
+    subscriptionVerify(p) {
+        return this.http.post('/v1/data/verify', { txHash: p.txHash }, { 'x-wallet-address': p.walletAddress });
+    }
+    /** 读取 DC 订阅用量（套餐 / key / 月配额 / 当前用量 / 日明细）。 */
+    subscriptionUsage(walletAddress) {
+        return this.http.get('/v1/data/usage', { 'x-wallet-address': walletAddress });
+    }
+}
+exports.DataAPI = DataAPI;

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+/** 引擎返回非 2xx 时抛出。`status` 为 HTTP 状态码，`code` 为契约错误码。 */
+export declare class KeelApiError extends Error {
+    readonly path: string;
+    readonly status: number;
+    readonly code: string;
+    readonly body: unknown;
+    constructor(path: string, status: number, code: string, body: unknown);
+}
+export declare function isKeelApiError(err: unknown): err is KeelApiError;

package/dist/errors.js

@@ -0,0 +1,22 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// @keelcodes/sdk — 类型化错误（对齐契约 §3）
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeelApiError = void 0;
+exports.isKeelApiError = isKeelApiError;
+/** 引擎返回非 2xx 时抛出。`status` 为 HTTP 状态码，`code` 为契约错误码。 */
+class KeelApiError extends Error {
+    constructor(path, status, code, body) {
+        super(`[keel-sdk] ${path} ${status} (${code}): ${body?.message ?? 'request failed'}`);
+        this.path = path;
+        this.status = status;
+        this.code = code;
+        this.body = body;
+        this.name = 'KeelApiError';
+    }
+}
+exports.KeelApiError = KeelApiError;
+function isKeelApiError(err) {
+    return err instanceof KeelApiError;
+}

package/dist/http.d.ts

@@ -0,0 +1,17 @@
+import type { KeelConfig } from './types';
+/** SDK 版本（契约 §5，基线 2.0.0，随包版本同步）。 */
+export declare const SDK_VERSION = "2.0.0";
+export declare class HttpClient {
+    private baseUrl;
+    private headers;
+    private timeout;
+    private wallet?;
+    private walletToken?;
+    constructor(config?: KeelConfig);
+    get<T>(path: string, headers?: Record<string, string>): Promise<T>;
+    post<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    put<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    private request;
+    /** 静态头 + （若配置）钱包签名头。签名按 WALLET_TOKEN_TTL_MS 复用。 */
+    private buildHeaders;
+}

package/dist/http.js

@@ -0,0 +1,76 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// @keelcodes/sdk — HTTP 客户端（统一 Bearer key + 钱包签名 + 错误分级）
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = exports.SDK_VERSION = void 0;
+const errors_1 = require("./errors");
+/** SDK 版本（契约 §5，基线 2.0.0，随包版本同步）。 */
+exports.SDK_VERSION = '2.0.0';
+/**
+ * 钱包签名的复用时长（ms）：首次签名后在该窗口内复用，避免每个请求都触发钱包弹窗。
+ * 服务端会话 TTL 为 24h，此处取 1h 留足余量。
+ */
+const WALLET_TOKEN_TTL_MS = 60 * 60 * 1000;
+class HttpClient {
+    constructor(config = {}) {
+        this.baseUrl = (config.baseUrl ?? 'https://keel.codes').replace(/\/+$/, '');
+        this.timeout = config.timeout ?? 30000;
+        this.headers = { 'Content-Type': 'application/json', 'X-Keel-Version': exports.SDK_VERSION };
+        if (config.apiKey)
+            this.headers['Authorization'] = `Bearer ${config.apiKey}`;
+        if (config.serviceKey)
+            this.headers['X-Service-Key'] = config.serviceKey;
+        if (config.wallet)
+            this.wallet = config.wallet;
+    }
+    async get(path, headers) {
+        return this.request('GET', path, undefined, headers);
+    }
+    async post(path, body, headers) {
+        return this.request('POST', path, body, headers);
+    }
+    async put(path, body, headers) {
+        return this.request('PUT', path, body, headers);
+    }
+    async request(method, path, body, extraHeaders) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        let res;
+        try {
+            res = await fetch(this.baseUrl + path, {
+                method,
+                headers: { ...(await this.buildHeaders()), ...extraHeaders },
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const json = await res.json().catch(() => ({}));
+        if (res.status < 200 || res.status >= 300) {
+            throw new errors_1.KeelApiError(path, res.status, json?.code ?? 'INTERNAL', json);
+        }
+        return json;
+    }
+    /** 静态头 + （若配置）钱包签名头。签名按 WALLET_TOKEN_TTL_MS 复用。 */
+    async buildHeaders() {
+        if (!this.wallet)
+            return this.headers;
+        const now = Date.now();
+        if (this.walletToken && now - this.walletToken.ts < WALLET_TOKEN_TTL_MS) {
+            return { ...this.headers, ...this.walletToken.headers };
+        }
+        const timestamp = String(now);
+        const signature = await this.wallet.sign(`InfraX auth: ${timestamp}`);
+        const headers = {
+            'x-wallet-address': this.wallet.address.toLowerCase(),
+            'x-wallet-timestamp': timestamp,
+            'x-wallet-signature': signature,
+        };
+        this.walletToken = { ts: now, headers };
+        return { ...this.headers, ...headers };
+    }
+}
+exports.HttpClient = HttpClient;