@clonegod/ttd-base-send-tx 0.1.1

package/dist/transaction_sender.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionSender = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const channels_1 = require("./channels");
+/**
+ * BASE 链 trader 端 TransactionSender
+ *
+ * ## 与 BSC 的差异
+ *
+ * BSC：3 builder bundle 并发（BlockRazor / 48Club / BLXR），主 tx + 3 tip tx 并行签名，bundle 投递
+ * BASE：无原生 bundle 通道；私有路由商（BlockRazor / bloXroute）走单笔 `eth_sendRawTransaction`
+ *
+ * ## 发送策略（fan-out 多端并发）
+ *
+ * 同一笔签名好的 raw tx 并发提交到所有启用的通道，先到的成功，
+ * 后到的同 nonce/同 signature 在 sequencer / mempool 端自然去重。
+ *
+ *   - `direct_rpc`：直发 BASE sequencer（endpoint = 通用 `RPC_ENDPOINT`，mainnet.base.org / 自家 endpoint，可启用 MEV Protection）
+ *   - `backup_rpc`：可选第二个 direct_rpc（`BACKUP_RPC_ENDPOINT`，不同 provider 做 RPC 故障冗余）
+ *   - `blockrazor`：BlockRazor BASE Fast（强制 tip，调用方需在 tx 中含 tip transfer 或抬高 priorityFee）
+ *   - `bloxroute`：bloXroute `blxr_tx`（可选 BackRunMe 回扣）
+ *
+ * ## ⚠️ BASE 上不存在 revert protection
+ *
+ * 失败的 tx **会**上链并扣 gas（跟 ETH 主网 Flashbots Protect 不同）。
+ * → 调用方必须先做链下模拟（eth_call / estimateGas），保证 tx 必成功才发
+ */
+class TransactionSender {
+    constructor(appConfig) {
+        this.channels = [];
+        const env = appConfig.env_args;
+        if (env.send_tx_direct_rpc) {
+            this.channels.push(new channels_1.DirectRpcChannel(env.rpc_endpoint || 'https://mainnet.base.org'));
+        }
+        if (env.send_tx_backup_rpc && env.backup_rpc_endpoint) {
+            this.channels.push(new channels_1.DirectRpcChannel(env.backup_rpc_endpoint));
+        }
+        if (env.send_tx_blockrazor) {
+            if (!env.blockrazor_auth_token) {
+                (0, ttd_core_1.log_warn)('[TransactionSender] SEND_TX_BLOCKRAZOR=true 但 BLOCKRAZOR_AUTH_TOKEN 未配置，跳过 BlockRazor 通道');
+            }
+            else {
+                this.channels.push(new channels_1.BlockRazorChannel(env.blockrazor_endpoint, env.blockrazor_auth_token));
+            }
+        }
+        if (env.send_tx_bloxroute) {
+            if (!env.bloxroute_auth_token) {
+                (0, ttd_core_1.log_warn)('[TransactionSender] SEND_TX_BLOXROUTE=true 但 BLOXROUTE_AUTH_TOKEN 未配置，跳过 bloXroute 通道');
+            }
+            else {
+                this.channels.push(new channels_1.BloxrouteChannel({
+                    url: env.bloxroute_endpoint,
+                    authToken: env.bloxroute_auth_token,
+                    backrunmeRewardAddress: env.bloxroute_backrunme_address || undefined,
+                }));
+            }
+        }
+        this.timeoutMs = env.send_tx_timeout_ms || 3000;
+        if (this.channels.length === 0) {
+            // 兜底：起码开主通道，避免空 sender 静默吞 tx
+            (0, ttd_core_1.log_warn)('[TransactionSender] 没有启用任何发送通道，回退到默认 direct_rpc');
+            this.channels.push(new channels_1.DirectRpcChannel(env.rpc_endpoint || 'https://mainnet.base.org'));
+        }
+        (0, ttd_core_1.log_info)(`[TransactionSender] BASE 启动，通道=${this.channels.map(c => c.name).join(',')}, timeout=${this.timeoutMs}ms`);
+        // 预热所有通道（fire-and-forget，不阻塞构造）。建立 TCP+TLS 连接复用给后续 sendTransaction，
+        // 第一笔真实交易免握手。
+        for (const ch of this.channels) {
+            ch.warmup?.().catch(() => { });
+        }
+    }
+    /**
+     * @param signedMainTx hex-encoded 主交易（无 tip 版本，发给非 tip 通道）
+     * @param channelTipTxMap channel name → 已签名 tx（同 nonce 的"含 tip"版本）
+     *                         举例：{ 'blockrazor' => withTipSignedTx }
+     *                         不在 map 中的 channel 收到 signedMainTx；在 map 中的 channel 收到对应 tx。
+     *                         Ethereum nonce 唯一性保证链上只有一笔执行，多通道并发安全。
+     * @param order_trace_id 订单追踪 id（日志用）
+     * @param pair 交易对名（日志用）
+     * @param _only_bundle BASE 忽略（无 bundle 概念）
+     * @param trace 可选 TradeTrace
+     */
+    async sendTransaction(signedMainTx, channelTipTxMap, order_trace_id, pair = '', _only_bundle = false, trace) {
+        trace?.mark('send_start');
+        const sends = this.channels.map(ch => {
+            const tx = channelTipTxMap?.get(ch.name) ?? signedMainTx;
+            return ch.send(tx, this.timeoutMs);
+        });
+        const results = await Promise.all(sends);
+        trace?.mark('send_done');
+        const ok = results.filter(r => !!r.txHash);
+        const fail = results.filter(r => !!r.error);
+        for (const r of ok) {
+            (0, ttd_core_1.log_info)(`[send] ✅ channel=${r.channel} trace=${order_trace_id} pair=${pair} ${r.elapsedMs}ms tx=${r.txHash}`);
+        }
+        for (const r of fail) {
+            (0, ttd_core_1.log_warn)(`[send] ❌ channel=${r.channel} trace=${order_trace_id} pair=${pair} ${r.elapsedMs}ms err=${r.error}`);
+        }
+        if (ok.length === 0) {
+            throw new Error(`所有 send 通道失败: ${fail.map(f => `${f.channel}=${f.error}`).join(' | ')}`);
+        }
+        return results.map(r => r.txHash ? `${r.channel}: ${r.txHash}` : `${r.channel}: ERR ${r.error}`);
+    }
+}
+exports.TransactionSender = TransactionSender;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@clonegod/ttd-base-send-tx",
+  "version": "0.1.1",
+  "description": "BASE send-tx 服务 + trader 端 SDK (Phase 7 待实现 — 目前为 stub)",
+  "license": "UNLICENSED",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "clean": "rm -rf dist node_modules",
+    "build": "tsc --outDir ./dist",
+    "start": "node dist/index.js",
+    "push": "npm run build && npm publish"
+  },
+  "dependencies": {
+    "@clonegod/ttd-core": "3.1.80",
+    "@clonegod/ttd-base-common": "1.1.8",
+    "dotenv": "^16.4.7",
+    "ethers": "^5.8.0",
+    "undici": "^6.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/channels/blockrazor.ts

@@ -0,0 +1,132 @@
+/**
+ * BlockRazor BASE Fast 通道
+ *
+ * - 文档：https://blockrazor.gitbook.io/blockrazor/tc/transaction-submission/fast/base
+ * - 协议：HTTP POST `eth_sendRawTransaction`（标准 JSON-RPC），与 direct_rpc 同形态
+ * - 认证：`Authorization: Bearer <token>` header
+ * - Endpoint：`http://base-fast.blockrazor.io`（默认）
+ * - 路由：私有 mempool + Speed Boost 转发给 sequencer
+ *
+ * ## 强制 tip 要求
+ *
+ * BlockRazor BASE Fast **强制**每笔 tx 给 tip：
+ *   方式 A：tx 内含 transfer ≥ 0.000003 ETH 到 `0x9D70AC39166ca154307a93fa6b595CF7962fe8e5`
+ *   方式 B：`maxPriorityFeePerGas` ≥ 估算成本的 5%
+ *
+ * **本通道只负责转发已签名 raw tx**。调用方（trade encode 侧）必须事先满足
+ * tip 要求，否则 BlockRazor 会 reject。
+ *
+ * ## TPS 限制
+ *
+ * - 默认 10 TPS（不分套餐）；联系 BlockRazor 升级。
+ */
+
+import { SendChannel, SendChannelResult } from './types'
+import { log_info, log_warn } from '@clonegod/ttd-core'
+import { Pool } from 'undici'
+
+interface JsonRpcResponse {
+    jsonrpc: string
+    id: number | string
+    result?: string
+    error?: { code: number; message: string }
+}
+
+const PING_INTERVAL_MS = 30_000
+
+export class BlockRazorChannel implements SendChannel {
+    readonly name = 'blockrazor'
+    private pool: Pool
+    private origin: string
+    private path: string
+    private authHeader: string
+    private pingTimer?: NodeJS.Timeout
+
+    constructor(private url: string, authToken: string) {
+        if (!authToken) {
+            throw new Error('[BlockRazorChannel] authToken is required')
+        }
+        const u = new URL(url)
+        this.origin = `${u.protocol}//${u.host}`
+        this.path = `${u.pathname}${u.search}` || '/'
+        this.authHeader = `Bearer ${authToken}`
+
+        this.pool = new Pool(this.origin, {
+            connections: 4,
+            pipelining: 1,
+            keepAliveTimeout: 10 * 60_000,
+            keepAliveMaxTimeout: 10 * 60_000,
+            headersTimeout: 5_000,
+            bodyTimeout: 5_000,
+        })
+    }
+
+    async warmup(timeoutMs: number = 5000): Promise<void> {
+        const t0 = Date.now()
+        try {
+            const json = await this.rpcCall('eth_chainId', [], timeoutMs)
+            if (json?.result) {
+                log_info(`[${this.name}] warmup OK ${this.url} chainId=${json.result} ${Date.now() - t0}ms`)
+            } else {
+                log_warn(`[${this.name}] warmup soft-fail ${this.url} ${Date.now() - t0}ms err=${json?.error?.message || 'no result'}`)
+            }
+        } catch (e: any) {
+            log_warn(`[${this.name}] warmup err ${this.url} ${Date.now() - t0}ms: ${e?.message || e}`)
+        }
+
+        if (!this.pingTimer) {
+            this.pingTimer = setInterval(() => {
+                this.rpcCall('eth_chainId', [], 3_000).catch(() => { /* silent */ })
+            }, PING_INTERVAL_MS)
+            this.pingTimer.unref?.()
+        }
+    }
+
+    async send(signedTx: string, timeoutMs: number): Promise<SendChannelResult> {
+        const t0 = Date.now()
+        try {
+            const json = await this.rpcCall('eth_sendRawTransaction', [signedTx], timeoutMs)
+            if (json?.error) {
+                return { channel: this.name, elapsedMs: Date.now() - t0, error: `RPC: ${json.error.message}` }
+            }
+            return { channel: this.name, elapsedMs: Date.now() - t0, txHash: json?.result }
+        } catch (e: any) {
+            const msg = e?.name === 'AbortError' || e?.message?.includes('aborted') ? `timeout(${timeoutMs}ms)` : (e?.message || String(e))
+            log_warn(`[${this.name}] send error: ${msg}`)
+            return { channel: this.name, elapsedMs: Date.now() - t0, error: msg }
+        }
+    }
+
+    private async rpcCall(method: string, params: any[], timeoutMs: number): Promise<JsonRpcResponse | null> {
+        const controller = new AbortController()
+        const timer = setTimeout(() => controller.abort(), timeoutMs)
+        try {
+            const { statusCode, body } = await this.pool.request({
+                method: 'POST',
+                path: this.path,
+                headers: {
+                    'content-type': 'application/json',
+                    'authorization': this.authHeader,
+                },
+                body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+                signal: controller.signal,
+            })
+            if (statusCode < 200 || statusCode >= 300) {
+                try { await body.text() } catch { /* ignore */ }
+                throw new Error(`HTTP ${statusCode}`)
+            }
+            const text = await body.text()
+            return JSON.parse(text) as JsonRpcResponse
+        } finally {
+            clearTimeout(timer)
+        }
+    }
+
+    async close(): Promise<void> {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer)
+            this.pingTimer = undefined
+        }
+        await this.pool.close()
+    }
+}

package/src/channels/bloxroute.ts

@@ -0,0 +1,161 @@
+/**
+ * bloXroute BASE 通道
+ *
+ * - 文档：https://docs.bloxroute.com/base/submit-transactions/submit-transactions
+ * - Speed Boost：https://docs.bloxroute.com/base/submit-transactions/speed-boost
+ * - 协议：HTTP POST `blxr_tx`（**非** eth_sendRawTransaction，是 bloXroute 私有方法）
+ * - 认证：`Authorization: <token>`（注意**无** Bearer 前缀）
+ * - Endpoint：`https://api.blxrbdn.com`
+ *
+ * ## 参数差异（vs 标准 JSON-RPC）
+ *
+ * - `transaction`: raw transactions bytes，**without `0x` prefix**
+ * - `blockchain_network`: 必须 `Base-Mainnet`
+ * - `backrunme_reward_address`: 可选——开启时自动注册 BackRunMe，回扣 MEV 利润到此地址
+ *
+ * ## 与 BlockRazor 的不同
+ *
+ * - **无强制 tip**：不需要 caller 在 tx 内含 transfer 或抬高 priorityFee
+ * - Speed Boost 需另购（通过 portal）；标准提交已经走私有路由
+ *
+ * ## 本通道做什么
+ *
+ * - 接收已签名 raw tx（带 0x 前缀），自动去前缀适配 bloXroute 协议
+ * - 注入 `blockchain_network = Base-Mainnet`
+ * - 可选注入 `backrunme_reward_address`
+ */
+
+import { SendChannel, SendChannelResult } from './types'
+import { log_info, log_warn } from '@clonegod/ttd-core'
+import { Pool } from 'undici'
+
+interface BlxrTxResponse {
+    jsonrpc?: string
+    id?: number | string
+    result?: { txHash?: string }
+    error?: { code?: number; message: string }
+}
+
+const PING_INTERVAL_MS = 30_000
+
+export interface BloxrouteChannelOptions {
+    /** 完整 url，例如 https://api.blxrbdn.com */
+    url: string
+    /** Authorization header 完整值（bloXroute 不带 Bearer 前缀） */
+    authToken: string
+    /** 可选：BackRunMe 回扣收款地址（开启回扣服务时填） */
+    backrunmeRewardAddress?: string
+}
+
+export class BloxrouteChannel implements SendChannel {
+    readonly name = 'bloxroute'
+    private pool: Pool
+    private origin: string
+    private path: string
+    private authHeader: string
+    private backrunmeRewardAddress?: string
+    private pingTimer?: NodeJS.Timeout
+
+    constructor(opts: BloxrouteChannelOptions) {
+        if (!opts.authToken) {
+            throw new Error('[BloxrouteChannel] authToken is required')
+        }
+        const u = new URL(opts.url)
+        this.origin = `${u.protocol}//${u.host}`
+        this.path = `${u.pathname}${u.search}` || '/'
+        this.authHeader = opts.authToken
+        this.backrunmeRewardAddress = opts.backrunmeRewardAddress || undefined
+
+        this.pool = new Pool(this.origin, {
+            connections: 4,
+            pipelining: 1,
+            keepAliveTimeout: 10 * 60_000,
+            keepAliveMaxTimeout: 10 * 60_000,
+            headersTimeout: 5_000,
+            bodyTimeout: 5_000,
+        })
+    }
+
+    /**
+     * bloXroute 没有 `eth_chainId` 这种标准 ping。
+     * 这里只建 TCP+TLS（请求一个肯定返回的 404/method-not-found，仍能让连接进入复用池）。
+     */
+    async warmup(timeoutMs: number = 5000): Promise<void> {
+        const t0 = Date.now()
+        try {
+            await this.postRaw('{"jsonrpc":"2.0","id":1,"method":"ping","params":[]}', timeoutMs)
+            log_info(`[${this.name}] warmup OK ${this.origin} ${Date.now() - t0}ms`)
+        } catch (e: any) {
+            log_warn(`[${this.name}] warmup err ${this.origin} ${Date.now() - t0}ms: ${e?.message || e}`)
+        }
+
+        if (!this.pingTimer) {
+            this.pingTimer = setInterval(() => {
+                this.postRaw('{"jsonrpc":"2.0","id":1,"method":"ping","params":[]}', 3_000)
+                    .catch(() => { /* silent */ })
+            }, PING_INTERVAL_MS)
+            this.pingTimer.unref?.()
+        }
+    }
+
+    async send(signedTx: string, timeoutMs: number): Promise<SendChannelResult> {
+        const t0 = Date.now()
+        // bloXroute 要求 raw tx **去掉 0x 前缀**
+        const rawTx = signedTx.startsWith('0x') ? signedTx.slice(2) : signedTx
+        const params: Record<string, any> = {
+            transaction: rawTx,
+            blockchain_network: 'Base-Mainnet',
+        }
+        if (this.backrunmeRewardAddress) {
+            params.backrunme_reward_address = this.backrunmeRewardAddress
+        }
+
+        try {
+            const body = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'blxr_tx', params })
+            const text = await this.postRaw(body, timeoutMs)
+            const json = JSON.parse(text) as BlxrTxResponse
+            if (json.error) {
+                return { channel: this.name, elapsedMs: Date.now() - t0, error: `RPC: ${json.error.message}` }
+            }
+            const hash = json.result?.txHash
+            const normalized = hash && !hash.startsWith('0x') ? `0x${hash}` : hash
+            return { channel: this.name, elapsedMs: Date.now() - t0, txHash: normalized }
+        } catch (e: any) {
+            const msg = e?.name === 'AbortError' || e?.message?.includes('aborted') ? `timeout(${timeoutMs}ms)` : (e?.message || String(e))
+            log_warn(`[${this.name}] send error: ${msg}`)
+            return { channel: this.name, elapsedMs: Date.now() - t0, error: msg }
+        }
+    }
+
+    private async postRaw(body: string, timeoutMs: number): Promise<string> {
+        const controller = new AbortController()
+        const timer = setTimeout(() => controller.abort(), timeoutMs)
+        try {
+            const { statusCode, body: respBody } = await this.pool.request({
+                method: 'POST',
+                path: this.path,
+                headers: {
+                    'content-type': 'application/json',
+                    'authorization': this.authHeader,
+                },
+                body,
+                signal: controller.signal,
+            })
+            const text = await respBody.text()
+            if (statusCode < 200 || statusCode >= 300) {
+                throw new Error(`HTTP ${statusCode}: ${text.slice(0, 200)}`)
+            }
+            return text
+        } finally {
+            clearTimeout(timer)
+        }
+    }
+
+    async close(): Promise<void> {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer)
+            this.pingTimer = undefined
+        }
+        await this.pool.close()
+    }
+}

package/src/channels/direct_rpc.ts

@@ -0,0 +1,143 @@
+/**
+ * 直发 sequencer RPC 通道（BASE 主路径）
+ *
+ * - HTTP POST eth_sendRawTransaction 到 BASE sequencer
+ * - 默认 https://mainnet.base.org（Coinbase 官方）
+ * - 生产建议换 Alchemy / QuickNode 的 private endpoint：跟 sequencer 有专线，延迟更低
+ *
+ * ## BASE 上为什么不需要"MEV 保护通道"
+ *
+ * BASE 是单 sequencer rollup（Coinbase 运维），具备 ETH 主网用 Flashbots Protect 想达到的特性：
+ *   1. **无公开 mempool**：sequencer 接收到的 tx 不广播给公网
+ *   2. **无 builder 竞价**：没有第三方 builder 看你的 tx，没有 PBS 拍卖
+ *   3. **Flashblocks 排序锁定**：tx 一旦进入 Flashblock 就不能被高 fee tx 越过
+ *
+ * Flashbots Protect 当前**不支持 BASE**（只支持 ETH 主网 + Sepolia），且事实上也不需要。
+ * 直发 sequencer 已经是 BASE 上的"最优策略"——速度即护身符。
+ *
+ * ## 延迟优化（vs Node 全局 fetch）
+ *
+ * 用持久化 undici Pool 替代全局 fetch，单独控制：
+ *   1. **keepAliveTimeout=10min**：服务端单方面断连前一直保活，arb 低谷期不掉
+ *   2. **keepAliveMaxTimeout=10min**：极限保活上限
+ *   3. **pipelining=1**：避免请求重排序导致的 nonce 抢跑
+ *   4. **connections=4**：单 host 4 个并发连接（足够 arb 突发）
+ *   5. **periodic ping**：每 30s 发 eth_chainId，强制走"已建立"连接防服务端 idle 断
+ *
+ * 累计收益：消除 ~100-300ms 冷启动 + arb 低谷期回弹的一致性问题。
+ *
+ * ## 注意事项
+ *
+ * - **无 revert protection**：失败的 tx 会上链扣 gas → 业务必须先做链下模拟
+ */
+
+import { SendChannel, SendChannelResult } from './types'
+import { log_info, log_warn } from '@clonegod/ttd-core'
+import { Pool } from 'undici'
+
+interface JsonRpcResponse {
+    jsonrpc: string
+    id: number | string
+    result?: string
+    error?: { code: number; message: string }
+}
+
+const PING_INTERVAL_MS = 30_000
+
+export class DirectRpcChannel implements SendChannel {
+    readonly name = 'direct_rpc'
+    private pool: Pool
+    private origin: string
+    private path: string
+    private pingTimer?: NodeJS.Timeout
+
+    constructor(private url: string) {
+        const u = new URL(url)
+        this.origin = `${u.protocol}//${u.host}`
+        this.path = `${u.pathname}${u.search}` || '/'
+
+        // 持久化 undici Pool：keep-alive 极长，确保 idle 期间不断
+        this.pool = new Pool(this.origin, {
+            connections: 4,
+            pipelining: 1,
+            keepAliveTimeout: 10 * 60_000,           // 10 分钟
+            keepAliveMaxTimeout: 10 * 60_000,
+            headersTimeout: 5_000,
+            bodyTimeout: 5_000,
+        })
+    }
+
+    /**
+     * 启动期预热 + 启动后台 ping。
+     * 预热建立 TCP+TLS，让第一笔真实交易免握手；
+     * 后台 ping 每 30s 走一次连接防服务端 idle 断。
+     */
+    async warmup(timeoutMs: number = 5000): Promise<void> {
+        const t0 = Date.now()
+        try {
+            const json = await this.rpcCall('eth_chainId', [], timeoutMs)
+            if (json?.result) {
+                log_info(`[${this.name}] warmup OK ${this.url} chainId=${json.result} ${Date.now() - t0}ms`)
+            } else {
+                log_warn(`[${this.name}] warmup soft-fail ${this.url} ${Date.now() - t0}ms err=${json?.error?.message || 'no result'}`)
+            }
+        } catch (e: any) {
+            log_warn(`[${this.name}] warmup err ${this.url} ${Date.now() - t0}ms: ${e?.message || e}`)
+        }
+
+        // 启动后台 ping（fire-and-forget，进程退出时随之回收）
+        if (!this.pingTimer) {
+            this.pingTimer = setInterval(() => {
+                this.rpcCall('eth_chainId', [], 3_000).catch(() => { /* 静默 — 失败由下一次 send 触发重连 */ })
+            }, PING_INTERVAL_MS)
+            this.pingTimer.unref?.()
+        }
+    }
+
+    async send(signedTx: string, timeoutMs: number): Promise<SendChannelResult> {
+        const t0 = Date.now()
+        try {
+            const json = await this.rpcCall('eth_sendRawTransaction', [signedTx], timeoutMs)
+            if (json?.error) {
+                return { channel: this.name, elapsedMs: Date.now() - t0, error: `RPC: ${json.error.message}` }
+            }
+            return { channel: this.name, elapsedMs: Date.now() - t0, txHash: json?.result }
+        } catch (e: any) {
+            const msg = e?.name === 'AbortError' || e?.message?.includes('aborted') ? `timeout(${timeoutMs}ms)` : (e?.message || String(e))
+            log_warn(`[${this.name}] send error: ${msg}`)
+            return { channel: this.name, elapsedMs: Date.now() - t0, error: msg }
+        }
+    }
+
+    private async rpcCall(method: string, params: any[], timeoutMs: number): Promise<JsonRpcResponse | null> {
+        const controller = new AbortController()
+        const timer = setTimeout(() => controller.abort(), timeoutMs)
+        try {
+            const { statusCode, body } = await this.pool.request({
+                method: 'POST',
+                path: this.path,
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+                signal: controller.signal,
+            })
+            if (statusCode < 200 || statusCode >= 300) {
+                // 消费 body 防内存泄露
+                try { await body.text() } catch { /* ignore */ }
+                throw new Error(`HTTP ${statusCode}`)
+            }
+            const text = await body.text()
+            return JSON.parse(text) as JsonRpcResponse
+        } finally {
+            clearTimeout(timer)
+        }
+    }
+
+    /** 测试/优雅停机用：销毁连接池 + 停 ping */
+    async close(): Promise<void> {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer)
+            this.pingTimer = undefined
+        }
+        await this.pool.close()
+    }
+}

package/src/channels/index.ts

@@ -0,0 +1,4 @@
+export * from './types'
+export * from './direct_rpc'
+export * from './blockrazor'
+export * from './bloxroute'

package/src/channels/types.ts

@@ -0,0 +1,34 @@
+/**
+ * 发送通道抽象 — 所有 BASE 发送通道（Flashbots Protect / 直发 sequencer / 未来的私有 RPC）
+ * 都通过一个统一接口暴露给 TransactionSender。
+ *
+ * 设计目标：
+ *   - 通道是纯函数：拿到 signedTx + timeout，返回结果或抛错；不关心策略/优先级
+ *   - TransactionSender 负责并发 / 顺序 / 重试编排
+ *   - 通道之间相互独立，可热插拔
+ */
+
+export interface SendChannelResult {
+    /** 通道名（用于日志/分析）*/
+    channel: string
+    /** sequencer / relay 返回的 tx hash（成功）；undefined = 失败但无 hash */
+    txHash?: string
+    /** 总耗时（ms）*/
+    elapsedMs: number
+    /** 错误信息（失败时）*/
+    error?: string
+}
+
+export interface SendChannel {
+    readonly name: string
+    /**
+     * @param signedTx hex-encoded raw transaction（必须以 0x 开头）
+     * @param timeoutMs 单次发送超时（ms）；超时即视为失败
+     */
+    send(signedTx: string, timeoutMs: number): Promise<SendChannelResult>
+    /**
+     * 可选：启动期连接预热（建立 TCP+TLS，复用给后续 send）。
+     * 实现方应 fire-and-forget：失败不抛错，仅 log。
+     */
+    warmup?(timeoutMs?: number): Promise<void>
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { TransactionSender } from './transaction_sender'
+export { BASE_EOA_ADDRESS } from '@clonegod/ttd-base-common'