OPC 3.0：2026 年自媒体 × Web3 × AI 一人公司进阶实操指南

Agentic 支付量:
  Base x402: 1 亿笔 / 3 个季度 (Chainalysis, Jun 2026)
  单笔 ≥ $1 占比: 95% (早期全是微支付，现已转向实用)
  活跃钱包: 年轻、多资产、小额余额 —— 典型 Agent 特征

Solana Agentic 支付:
  市场份额: 65% (Coinfomania, May 2026)
  原因: 400ms 确认、<$0.001 费用、Solana Pay SDK 成熟
  典型场景: Agent-to-Agent 微服务调用、数据订阅、推理付费

Micro-SaaS 现实:
  单人 $10K+ MRR 增长: +23% YoY (Indie Hackers 2026)
  失败率: 横向通用工具 67% 死掉
  成功密钥: 垂直细分 < 100k TAM、AI 把边际成本压到 ≈0

身份与钱包层:
  钱包: Privy / Dynamic (嵌入式钱包，Web2 用户 0 摩擦)
  DID: ENS + Lens Handle (双轨：ENS 给钱包，Lens 给社交图谱)
  签名: EIP-712 结构化签名 → Agent 自主签交易 (需设额度)

Agent 运行层:
  编排: Hermes Agent (自托管，跨会话记忆，70+ 工具，20+ 网关)
  子 Agent: 通过 `delegate_task` 并行生成：研报/切片/客服/增长/财务
  模型: OpenRouter (统一入口) → GPT-4o / Claude 3.5 / DeepSeek-V3 / Llama-3.3-70B
  链上验证: Othentic / EigenLayer AVS (关键推理结果上链证明)
  存储: Supabase (热) + Arweave (冷/永久) + IPFS via Fleek (前端)

支付与结算层:
  主网: **Base (x402 原生)** + **Solana (高频微支付)**
  协议: x402 (HTTP 402 + 稳定币) + Solana Pay (二维码/链接支付)
  订阅: Superfluid 流式支付 (按秒计费 Agent API)
  法币桥: Stripe Crypto / Bridge.xyz (USDC ⇄ 银行卡自动结算)

分发与增长层:
  协议: Farcaster (Frames + Neynar SDK) + Lens (Open Actions)
  SEO: Astro + Hugo 双端 → IPFS + Vercel + Cloudflare Pages
  邮件: Resend + 链上订阅 NFT 门控
  视频: Livepeer (去中心化转码) + Farcaster Video

合规与后台:
  实体: Wyoming LLC + Stripe Atlas (或新加坡 VCC)
  税务: Koinly / CoinTracker API + Hermes cronjob 季度自动生成报表
  银行: Mercury / Brex (支持加密友好)
  法务: OpenLaw 模板 + Agent 审合同风险

Base (战略主链):
  x402 原生支持：HTTP 402 响应自动触发 USDC 支付
  Coinbase 1.1 亿用户入金通道
  费用: ~$0.005，适合 ≥$1 的 Agent 服务付费
  生态: Coinbase AgentKit、OnchainKit、CDP SDK 成熟

Solana (高频微支付链):
  65% Agentic 支付已在这
  400ms 确认、<$0.001 费用 → 适合 Agent-to-Agent 千次/秒调用
  Solana Pay + Blinks：一键支付嵌入任何前端
  SDK: Anchor + TypeScript 客户端最成熟

桥接策略:
  Wormhole / LayerZero / deBridge 自动套利再平衡
  Hermes Agent 内置 `rebalance_treasury` 技能：日度跑批

# 1. 克隆模板仓库（已内置所有配置）
git clone https://github.com/yourname/opc3-agent-hq.git
cd opc3-agent-hq

# 2. 填入 .env（见文末完整清单）
cp .env.example .env
# 必填：OPENAI_KEY, ANTHROPIC_KEY, OPENROUTER_KEY
# 必填：BASE_RPC, SOLANA_RPC, PRIVY_APP_ID, PRIVY_APP_SECRET
# 必填：NEYNAR_API_KEY, LENS_API_KEY, RESSEND_API_KEY
# 必填：STRIPE_SECRET, COINBASE_COMMERCE_KEY
# 必填：HERMES_TELEGRAM_TOKEN, HERMES_DISCORD_WEBHOOK

# 3. 一键启动（Docker Compose，含 Postgres + Redis + Hermes + 前端）
docker compose up -d

# ~/.hermes/config.yaml
profile: opc3
model:
  provider: openrouter
  model: anthropic/claude-3.5-sonnet
memory:
  enabled: true
  backend: sqlite
  summary_model: openrouter/google/gemini-flash-1.5
tools:
  enabled:
    - web_search
    - web_extract
    - browser
    - terminal
    - file
    - cronjob
    - delegate_task
    - skills
    - send_message
    - vision_analyze
    - text_to_speech
delegation:
  max_concurrent_children: 5
  max_spawn_depth: 2
cron:
  enabled: true
  jobs:
    - name: daily_content_factory
      schedule: "0 6 * * *"
      prompt: "运行 daily_content.py 生成今日 3 条 Farcaster + 1 篇长文 + 5 条切片"
      skills: ["content-factory"]
    - name: treasury_rebalance
      schedule: "0 3 * * *"
      prompt: "检查 Base/Solana 金库比例，按 6:4 再平衡，Gas 费 < $5 时执行"
      skills: ["defi-treasury"]
    - name: quarterly_tax_report
      schedule: "0 9 1 */3 *"
      prompt: "拉取所有链上收支，生成 Koinly 兼容 CSV，发送给会计师邮箱"
      skills: ["tax-compliance"]

# 预加载技能（见文末 skills/ 目录）
skills:
  - content-factory
  - defi-treasury
  - tax-compliance
  - farcaster-growth
  - agent-swarm-manager

# 检查 Hermes 存活
curl http://localhost:8080/health  # {"status":"ok","profile":"opc3"}

# 发测试消息到 Telegram
hermes send --platform telegram --text "OPC 3.0 Agent HQ 上线 🚀"

# 触发一次内容工厂干跑
hermes cron run daily_content_factory --dry-run

#!/usr/bin/env python3
"""
OPC 3.0 每日内容工厂
每天 06:00 由 Hermes cronjob 触发，产出：
  - 3 条 Farcaster Cast (含 Frame)
  - 1 篇深度长文 (Mirror + IPFS + Hugo)
  - 5 条短视频切片脚本 (Livepeer 转码 → Farcaster Video)
  - 1 份 Alpha 简报 (Telegram/Discord 群推送)
"""

import os, json, asyncio, datetime
from pathlib import Path
from hermes_tools import web_search, web_extract, delegate_task, send_message

TRENDS_SOURCES = [
    "https://api.coingecko.com/api/v3/search/trending",
    "https://api.llama.fi/protocols",
    "https://farcaster.xyz/api/trending-casts",
    "https://api.kaito.ai/v1/alpha-signals",
]

async def fetch_trends() -> list[dict]:
    """聚合多源热点，去重、打分"""
    results = []
    for url in TRENDS_SOURCES:
        try:
            data = (await web_extract([url]))["results"][0]["content"]
            results.append({"source": url, "raw": data[:3000]})
        except Exception as e:
            print(f"[WARN] {url}: {e}")
    return results

async def plan_content(trends: list[dict]) -> dict:
    """主 Agent 生成内容日历"""
    prompt = f"""
你是 OPC 3.0 内容总监。基于以下原始热点数据，制定今日内容日历：

{json.dumps(trends, ensure_ascii=False)[:8000]}

输出 JSON，字段：
- farcaster_casts: 3 条，每条含 text, frame_url(可选), tags[]
- longform: {{title, outline[5-7], target_keywords[], cta}}
- clips: 5 条，每条 {{hook, script_60s, visual_cue}}
- alpha_brief: {{headline, bullets[5], risk_warning}}

要求：
1. 紧扣「Agent 经济 / DeAI / 单人公司 / 链上变现」
2. 每条含 1 个可执行 CTA (Frame / Blink / 链接)
3. 避免纯蹭热点，必须有「你的独特框架/数据/工具」视角
"""
    result = await delegate_task(
        goal="生成今日内容日历 JSON",
        context=prompt,
        toolsets=["web", "skills"]
    )
    return json.loads(result[0]["summary"])

async def spawn_workers(plan: dict):
    """并行派发 5 个子 Agent"""
    tasks = [
        ("farcaster", "生成 3 条 Cast，含 Frame HTML，推送到 Neynar"),
        ("longform", "按大纲写完整长文，发布到 Mirror + IPFS + Hugo content/posts/"),
        ("clips", "生成 5 条 60s 切片脚本 + 分镜，调用 Livepeer API 转码"),
        ("video", "合成 1 条 3min 深度视频，上传 Farcaster Video"),
        ("alpha", "生成 Alpha 简报，推送 Telegram/Discord/Email"),
    ]
    results = await asyncio.gather(*[
        delegate_task(goal=g, context=f"日历：{json.dumps(plan, ensure_ascii=False)}", toolsets=["web", "file", "send_message"])
        for _, g in tasks
    ])
    return dict(zip([t[0] for t in tasks], [r[0]["summary"] for r in results]))

async def main():
    trends = await fetch_trends()
    plan = await plan_content(trends)
    outputs = await spawn_workers(plan)

    Path("logs").mkdir(exist_ok=True)
    (Path("logs") / f"{datetime.date.today()}.json").write_text(
        json.dumps({"plan": plan, "outputs": outputs}, ensure_ascii=False, indent=2)
    )
    print("[DONE] 每日内容工厂跑批完成")

if __name__ == "__main__":
    asyncio.run(main())

# 手动触发一次（调试用）
hermes cron run daily_content_factory

# 查看最近 3 次执行日志
hermes cron log daily_content_factory --limit 3

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@erc6551/contracts/ERC6551Registry.sol";

contract AgentNFT is ERC721, Ownable {
    using ERC6551Registry for address;

    IERC20 public immutable USDC;
    uint256 public constant PROTOCOL_FEE_BPS = 3000; // 30%
    uint256 public constant OWNER_SHARE_BPS = 3000; // 30%
    uint256 public constant TREASURY_BPS = 4000;    // 40%

    struct AgentConfig {
        string metadataURI;    // 指向 Agent 技能/人设 JSON
        uint256 computeBudget; // 每月算力预算 (USDC)
        bool active;
    }
    mapping(uint256 => AgentConfig) public agents;

    constructor(address _usdc) ERC721("OPC Agent", "OPCA") Ownable(msg.sender) {
        USDC = IERC20(_usdc);
    }

    function mintAgent(string calldata uri, uint256 budget) external payable returns (uint256) {
        require(msg.value >= 200 * 1e6, "Min 200 USDC"); // 简化：最低 200 USDC
        _safeMint(msg.sender, _tokenIdCounter.current());
        agents[_tokenIdCounter.current()] = AgentConfig(uri, budget, true);
        // 创建 ERC-6551 TBA (Token Bound Account)
        address tba = address(0).createERC6551Account(
            ERC6551RegistryImplementation, 0, address(this), _tokenIdCounter.current(), 0, ""
        );
        // TBA 自动接收后续 Agent 收入
        return _tokenIdCounter.current();
    }

    // Agent 执行付费任务后调用：收入按 30/30/40 自动分成
    function distributeRevenue(uint256 tokenId, uint256 amount) external {
        AgentConfig storage ag = agents[tokenId];
        require(ag.active, "Agent paused");
        address owner = ownerOf(tokenId);
        address tba = address(0).getERC6551Account(ERC6551RegistryImplementation, 0, address(this), tokenId, 0);

        uint256 protocol = amount * PROTOCOL_FEE_BPS / 10000;
        uint256 ownerShare = amount * OWNER_SHARE_BPS / 10000;
        uint256 treasury = amount * TREASURY_BPS / 10000;

        USDC.safeTransfer(owner, ownerShare);
        USDC.safeTransfer(treasuryWallet, protocol + treasury); // 合并入金库
        // TBA 保留算力预算自动支付推理费
    }

    function pauseAgent(uint256 tokenId) external onlyOwner {
        agents[tokenId].active = false;
    }
}

// apps/web/app/api/agent/[slug]/route.ts
import { x402 } from "@coinbase/x402";
import { createFlow } from "@superfluid-finance/sdk-core";

export async function GET(req: Request, { params }: { params: { slug: string } }) {
  // 1. x402 中间件自动拦截：无支付 → 返回 402 + Payment Required
  const payment = await x402.verify(req, {
    amount: "20", // $20 USDC
    recipient: process.env.NEXT_PUBLIC_TREASURY!,
    network: "base",
  });
  if (!payment.paid) return payment.response; // 自动处理 402 流程

  // 2. 支付成功 → 开启 Superfluid 流式订阅（按秒计费，随时取消）
  const flow = await createFlow({
    token: USDCx_ADDRESS,
    sender: payment.payer,
    receiver: TREASURY,
    flowRate: "20000000000000000", // 20 USDC/月 ≈ 7.6 wei/sec
    userData: `agent:${params.slug}`,
  });

  // 3. 返回 Agent API 端点 + TBA 地址
  return Response.json({ apiEndpoint: `https://api.opc3.io/agent/${params.slug}`, tba: flow.receiver });
}

# 1. 在 Zora.co 连接钱包 → Create Coin
# 名称: $OPC3 / Ticker: OPC3
# 初始供应: 100M，无预挖，100% 绑定曲线
# 绑定参数: 线性曲线，斜率 = 0.0001 ETH/token

# 2. 立即把 10% 供应空投给 L3 Agent NFT 持有者
# 3. 内容 NFT (Mirror/Lens) 设置 $OPC3 门控
# 4. Hermes Agent 每周自动回购: 协议收入 10% → 市场买入 $OPC3

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract OPCToken is ERC20, ERC20Votes, ERC20Permit, Ownable, ReentrancyGuard {
    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 10**18; // 1B
    uint256 public immutable LAUNCH_TIME;

    // 质押分红
    mapping(address => uint256) public stakedBalance;
    uint256 public totalStaked;
    uint256 public rewardsPerTokenStored;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    // Agent 算力支付销毁
    uint256 public totalBurned;

    constructor() ERC20("OPC 3.0 Protocol", "OPC3") ERC20Permit("OPC3") Ownable(msg.sender) {
        LAUNCH_TIME = block.timestamp;
        _mint(msg.sender, 300_000_000 * 10**18); // 30% 团队/金库，线性释放 4 年
        _mint(msg.sender, 200_000_000 * 10**18); // 20% 生态基金，DAO 管理
        // 50% 留给社区挖矿/空投/流动性
    }

    function stake(uint256 amount) external nonReentrant {
        _updateRewards(msg.sender);
        stakedBalance[msg.sender] += amount;
        totalStaked += amount;
        _transfer(msg.sender, address(this), amount);
    }

    function claimRewards() external nonReentrant {
        _updateRewards(msg.sender);
        uint256 r = rewards[msg.sender];
        require(r > 0, "No rewards");
        rewards[msg.sender] = 0;
        _transfer(address(this), msg.sender, r);
    }

    // 协议收入调用：注入分红池
    function notifyReward(uint256 amount) external onlyOwner {
        rewardsPerTokenStored += amount * 10**18 / totalStaked;
    }

    // Agent 支付推理费 → 买入销毁
    function payComputeFee() external payable {
        // 简化：直接销毁 msg.value 对应的 OPC3 (需预言机)
        totalBurned += msg.value;
    }

    function _updateRewards(address account) internal {
        uint256 newRewards = stakedBalance[account] * (rewardsPerTokenStored - userRewardPerTokenPaid[account]) / 10**18;
        rewards[account] += newRewards;
        userRewardPerTokenPaid[account] = rewardsPerTokenStored;
    }

    // 投票权委托 (用于 Snapshot / Tally)
    function delegate(address to) external { _delegate(msg.sender, to); }
}

# 1. 安装
curl -L https://foundry.paradigm.xyz | bash && foundryup

# 2. 初始化
forge init opc3-token && cd opc3-token
forge install openzeppelin/[email protected]

# 3. 放入合约 → contracts/OPCToken.sol
# 4. 测试
forge test -vv

# 5. 部署 Base Mainnet
forge script script/Deploy.s.sol --rpc-url $BASE_RPC --broadcast --verify

# 6. 验证
cast call <ADDRESS> "name()(string)" --rpc-url $BASE_RPC

# .github/workflows/contributor-rewards.yml
name: Monthly Contributor Rewards
on:
  schedule: ["0 0 1 * *"]  # 每月 1 号
jobs:
  allocate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: 拉取 Coordinape 圈子 GIVE 数据
        run: |
          curl -H "Authorization: Bearer *** \
            "https://api.coordinape.com/v1/circles/$CIRCLE_ID/gifts" > gifts.json
      - name: Hermes Agent 审计交付物
        run: |
          hermes cron run audit_contributions --input gifts.json --output verified.json
          # Agent 自动：检查 PR merged / 文档更新 / 视频发布 / 代码部署
      - name: 计算奖励并分发 (Superfluid)
        run: |
          python scripts/distribute_rewards.py verified.json
          # 输出: address, amount, stream_id

## OPC3-YYYY-MM-XXX: [标题]

### 类别
- [ ] 金库支出 (> $10k 需核心委员会多签)
- [ ] 参数调整 (费率 / 通胀 / 算力预算)
- [ ] 协议升级 (合约 / 前端 / Agent 技能)
- [ ] 生态拨款 (≤ $10k 走贡献者层快速通道)

### 背景与动机
[一句话：解决什么问题，为什么现在做]

### 执行方案
1. 步骤 1 (由谁执行，Agent 还是人)
2. 步骤 2 ...
3. 回滚方案

### 预算
| 项目 | 金额 | 代币/稳定币 | 支付方式 |
|------|------|-------------|----------|
| 开发 | 5000 | USDC | Safe 多签 / Superfluid |
| 审计 | 2000 | $OPC3 | 质押池释放 |

### 成功指标 (KPI)
- 指标 1: 目标值 (由 Agent 每周自动上报)
- 指标 2: 目标值

### 投票
- Snapshot 投票链接: [...]
- 通过门槛: 4% $OPC3 供应量参与 + 60% 赞成
- 执行: 通过后 48h 由执行 Agent 自动落地

#!/usr/bin/env python3
"""
Agent Swarm Manager - Hermes 技能
每 5 分钟跑一次：健康检查 + 自动重启 + 按负载扩缩容
"""

import asyncio, json, os, subprocess, time
from dataclasses import dataclass
from hermes_tools import delegate_task, send_message

@dataclass
class AgentSpec:
    name: str
    min_replicas: int
    max_replicas: int
    cpu_threshold: float
    memory_limit_mb: int

SWARM = [
    AgentSpec("content-factory", 1, 3, 70, 2048),
    AgentSpec("farcaster-growth", 2, 5, 60, 1024),
    AgentSpec("customer-support", 1, 10, 50, 512),
    AgentSpec("alpha-scout", 1, 2, 80, 4096),
]

async def get_metrics(name: str) -> dict:
    result = subprocess.run(
        ["docker", "stats", "--no-stream", "--format", "{{json .}}", f"hermes-{name}*"],
        capture_output=True, text=True
    )
    return [json.loads(l) for l in result.stdout.strip().split("\n") if l]

async def scale_agent(spec: AgentSpec, current: int, target: int):
    if target == current: return
    action = "scale up" if target > current else "scale down"
    await send_message(
        platform="telegram",
        text=f"🔧 Agent Swarm: {spec.name} {action} {current} → {target}"
    )

async def health_check():
    for spec in SWARM:
        metrics = await get_metrics(spec.name)
        healthy = len([m for m in metrics if float(m["CPUPerc"].rstrip("%")) < 90])
        if healthy < spec.min_replicas:
            await scale_agent(spec, healthy, spec.min_replicas)
        elif healthy > 0:
            avg_cpu = sum(float(m["CPUPerc"].rstrip("%")) for m in metrics) / len(metrics)
            if avg_cpu > spec.cpu_threshold and len(metrics) < spec.max_replicas:
                await scale_agent(spec, len(metrics), len(metrics) + 1)

async def main():
    while True:
        await health_check()
        await asyncio.sleep(300)

if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
"""
税务合规 Agent - 每季度自动生成报表
输入：所有链上地址 + 银行 API + Stripe API
输出：Koinly CSV + TurboTax 导入包 + 会计师邮件草稿
"""

import asyncio, csv, json, os
from datetime import datetime, timedelta
from pathlib import Path
from hermes_tools import web_extract, delegate_task, send_message

CHAINS = {
    "base": {"rpc": os.getenv("BASE_RPC"), "explorer": "basescan.org"},
    "solana": {"rpc": os.getenv("SOLANA_RPC"), "explorer": "solscan.io"},
    "ethereum": {"rpc": os.getenv("ETH_RPC"), "explorer": "etherscan.io"},
}

async def fetch_onchain_txs(addresses: list[str], start: datetime, end: datetime) -> list[dict]:
    """聚合多链交易 (简化：用 Covalent / Alchemy / Helius API)"""
    all_txs = []
    for chain, cfg in CHAINS.items():
        for addr in addresses:
            # 实际调用：curl "https://api.covalenthq.com/v1/{chain}/address/{addr}/transactions_v2/"
            # 这里模拟
            all_txs.append({
                "chain": chain, "address": addr,
                "hash": "0x...", "timestamp": start.isoformat(),
                "type": "swap", "token_in": "USDC", "amount_in": "1000",
                "token_out": "OPC3", "amount_out": "50000",
                "value_usd": 1000, "gas_usd": 2.5
            })
    return all_txs

async def fetch_offchain_income() -> list[dict]:
    """Stripe / 银行 / 支付宝 / 微信"""
    # 实际调用 Stripe API / Plaid / 银行开放 API
    return [
        {"source": "stripe", "date": "2026-01-15", "amount_usd": 5000, "type": "subscription"},
        {"source": "mercury_bank", "date": "2026-02-01", "amount_usd": 12000, "type": "wire_in"},
    ]

def to_koinly_csv(txs: list[dict], offchain: list[dict], outfile: Path):
    """生成 Koinly 通用 CSV"""
    fields = ["Date", "Sent Amount", "Sent Currency", "Received Amount", "Received Currency",
              "Fee Amount", "Fee Currency", "Net Worth Amount", "Net Worth Currency",
              "Label", "Description", "TxHash"]
    with open(outfile, "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=fields)
        w.writeheader()
        for tx in txs:
            w.writerow({
                "Date": tx["timestamp"][:10],
                "Sent Amount": tx.get("amount_in", ""),
                "Sent Currency": tx.get("token_in", ""),
                "Received Amount": tx.get("amount_out", ""),
                "Received Currency": tx.get("token_out", ""),
                "Fee Amount": tx.get("gas_usd", ""),
                "Fee Currency": "USD",
                "Label": tx["type"],
                "Description": f"{tx['chain']}:{tx['hash'][:10]}",
                "TxHash": tx["hash"],
            })
        for oc in offchain:
            w.writerow({
                "Date": oc["date"],
                "Received Amount": oc["amount_usd"],
                "Received Currency": "USD",
                "Label": "income",
                "Description": f"{oc['source']}:{oc['type']}",
            })

async def main():
    addresses = json.loads(os.getenv("WATCH_ADDRESSES", "[]"))
    end = datetime.utcnow()
    start = end - timedelta(days=90)  # 季度
    
    onchain = await fetch_onchain_txs(addresses, start, end)
    offchain = await fetch_offchain_income()
    
    outdir = Path("tax_reports") / f"Q{(end.month-1)//3+1}_{end.year}"
    outdir.mkdir(parents=True, exist_ok=True)
    
    to_koinly_csv(onchain, offchain, outdir / "koinly_import.csv")
    
    # 生成会计师摘要
    summary = f"""
OPC 3.0 季度税务摘要 - Q{(end.month-1)//3+1} {end.year}
链上交易: {len(onchain)} 笔
链下收入: {sum(o['amount_usd'] for o in offchain):.2f} USD
预估应税所得: 需会计师核对
文件: {outdir}/koinly_import.csv
"""
    (outdir / "summary.txt").write_text(summary)
    
    await send_message(
        platform="email",
        text=f"📊 季度税务报表已生成\n{summary}\n附件见 {outdir}"
    )
    print(f"[DONE] {outdir}")

if __name__ == "__main__":
    asyncio.run(main())

# === AI 模型 ===
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
OPENROUTER_API_KEY=sk-or-...
DEEPSEEK_API_KEY=sk-...

# === 区块链 RPC ===
BASE_RPC=https://mainnet.base.org
BASE_RPC_WS=wss://mainnet.base.org
SOLANA_RPC=https://api.mainnet-beta.solana.com
ETH_RPC=https://eth.llamarpc.com

# === 钱包/身份 ===
PRIVY_APP_ID=...
PRIVY_APP_SECRET=...
WALLET_PRIVATE_KEY=0x...  # 仅测试用，生产用硬件钱包
ENS_NAME=yourname.eth

# === 社交/分发 ===
NEYNAR_API_KEY=...
LENS_API_KEY=...
FARCASTER_SIGNER_PRIVATE_KEY=0x...
RESEND_API_KEY=re_...
TELEGRAM_BOT_TOKEN=...
TELEGRAM_CHAT_ID=...
DISCORD_WEBHOOK_URL=...

# === 支付/结算 ===
STRIPE_SECRET_KEY=sk_live_...
STRIPE_WEBHOOK_SECRET=whsec_...
COINBASE_COMMERCE_API_KEY=...
X402_FACILITATOR_URL=https://x402.facilitator.coinbase.com
SUPERFLUID_RPC_URL=https://mainnet.base.org
USDC_ADDRESS=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913

# === 数据/存储 ===
SUPABASE_URL=https://xxx.supabase.co
SUPABASE_SERVICE_KEY=eyJ...
ARWEAVE_WALLET=wallet.json
FLEEK_API_KEY=...
PINATA_JWT=...

# === 税务/合规 ===
COINTRACKER_API_KEY=...
KOINLY_API_KEY=...
ACCOUNTANT_EMAIL=[email protected]

# === 监控/告警 ===
GRAFANA_WEBHOOK=...
PAGERDUTY_KEY=...
SENTRY_DSN=...

# === Hermes 专用 ===
HERMES_TELEGRAM_TOKEN=...
HERMES_DISCORD_TOKEN=...
HERMES_PROFILE=opc3

---
name: content-factory
description: 每日自动产出 3 Cast + 1 长文 + 5 切片 + 1 简报
version: "1.0"
tags: [content, cron, delegate_task, farcaster, mirror]
tools: [web_search, web_extract, delegate_task, send_message, file, cronjob]
---