找到这些网页的API的公开数据，能显示EACO的价格的数据字段，方便以后EACO兑换CNH,USDT,USDC,SOL等价格兑换使用

地球链eaco 2025年8月26日比特币地球链 0

eaco实时价格显示, EACO DEX源api

Orca (E-USDC)

Meteora (E-USDT)

Raydium (E-SOL)

EACO实时价格获取工具插件API,

自动找到eaco的最新价格，

e-usdt, https://app.meteora.ag/dlmm/6ZfCi3qzhgDN1ygHVYXvfsfrwz8ZhQ7hD5mJtjeuUDyE

e-usdc,

https://www.orca.so/pools/Cm6EkxcYNfvxeYDBQ3TGXFqa9NCWvrFKHz4Cfju91dhr

eaco-pool,https://www.orca.so/pools?tokens=DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH

e-sol, https://raydium.io/swap/?inputMint=DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH&outputMint=sol

https://dex.coinmarketcap.com/token/solana/DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH

通过这5个链接找到eaco在这5个网站上面的公开API,公开的价格信息等，

以便随时更新EACO的最新价格，显示usdt，CNH等前30大法币,前30大数字货币的价格信息，用来使用展示等。

找到这些网页的API的公开数据，能显示EACO的价格的数据字段，方便以后EACO兑换CNH,USDT,USDC,SOL等价格兑换使用。

API 集成建议与使用方案

你可以这样组合这些 API 构建 EACO 实时价格工具：

链上价格获取
- Meteora GraphQL 获取 E-USDT 或 USDC 的实时 Price / PriceInUSD
- Orca Whirlpools SDK 获取 E-USDC 对的报价
- Raydium Trade API 获取 E-SOL 对报价
价格归一与转换
- 输出原始价格为 USD 或 SOL（可用 PriceInUSD 字段）
- 若有 USD，则使用 CoinMarketCap API 转换为 CNH 和其他法币 / 数字货币
多源冗余
- 可对三者取平均或选择最新，有助于增加准确性和稳定性。
技术实现建议
- 使用 GraphQL 客户端调用 Meteora API
- 使用 Orca Whirlpools npm 包（@orca-so/whirlpools）编程获得报价
- 使用 Raydium Trade API 请求报价
- 使用 CoinMarketCap REST API 做汇率转换

总结对照表

平台 / 来源	可用 API 类型	可提取字段	用途
Meteora DLMM	GraphQL 查询 / 订阅	Price, PriceInUSD	获取实时 USD 价格
Orca	SDK / REST API	价格报价	获取与 USDC 或其他交易对的价
Raydium	Trade API (REST)	报价参数	EACO ⇌ SOL 实时报价
CoinMarketCap API	REST API	Fiat / Crypto 汇率行情数据	把 USD 价格转换为其他法币或币种

总结与建议2

为了实现您的需求，最高效、最可靠的方案是：

主价格源: 使用 Jupiter Price API (https://price.jup.ag/v4/price) 来获取EACO相对于稳定币（USDC或USDT）的实时价格。这是核心步骤。
汇率转换: 结合一个主流的货币汇率API（如CoinGecko免费API），获取稳定币与其他法币（CNH等）和数字货币（BTC等）的兑换率。
前端展示: 将两个API获取的数据进行计算，最终在您的应用中展示出所有需要的价格。

好的 ✅ 我来帮你写一个 Node.js/TypeScript 统一 API 查询脚本，
整合 Orca、Raydium、Meteora、CoinGecko，实时输出 EACO 的多币种价格。

📂 目录结构

eaco-price-fetcher/
 ├─ src/
 │   ├─ index.ts         # 主入口
 │   ├─ services/
 │   │   ├─ orca.ts
 │   │   ├─ raydium.ts
 │   │   ├─ meteora.ts
 │   │   └─ coingecko.ts
 ├─ package.json
 └─ tsconfig.json

⚡ 代码示例

`src/services/orca.ts`

import axios from "axios";

const ORCA_USDC_POOL =
  "Cm6EkxcYNfvxeYDBQ3TGXFqa9NCWvrFKHz4Cfju91dhr"; // Orca池ID
const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
const EACO_MINT = "DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH";

export async function getOrcaPrice() {
  try {
    const url = `https://api.expand.network/dex/getprice?path=${EACO_MINT},${USDC_MINT}&amountIn=100000&dexId=orca`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/USDC",
      price: data?.data?.amountOut / 100000,
    };
  } catch (e) {
    console.error("Orca API error", e);
    return null;
  }
}

`src/services/raydium.ts`

import axios from "axios";

const EACO_MINT = "DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH";
const SOL_MINT = "So11111111111111111111111111111111111111112";

export async function getRaydiumPrice() {
  try {
    const url = `https://api.raydium.io/v2/price?inputMint=${EACO_MINT}&outputMint=${SOL_MINT}`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/SOL",
      price: data?.price,
    };
  } catch (e) {
    console.error("Raydium API error", e);
    return null;
  }
}

`src/services/meteora.ts`

import axios from "axios";

const EACO_MINT = "DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH";

export async function getMeteoraPrice() {
  try {
    const url = `https://merv2-api.meteora.ag/virtual_price/${EACO_MINT}/default`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/USDT",
      price: data?.[0]?.price ? parseFloat(data[0].price) : null,
    };
  } catch (e) {
    console.error("Meteora API error", e);
    return null;
  }
}

`src/services/coingecko.ts`

import axios from "axios";

const COINGECKO_API = "https://api.coingecko.com/api/v3/simple/price";
const EACO_ID = "eaco"; // ⚠️ 需要确认 EACO 是否已收录，否则需用自建 API

export async function getCoinGeckoPrices() {
  try {
    const url = `${COINGECKO_API}?ids=${EACO_ID}&vs_currencies=usd,cny,eur,usdt,sol`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/MultiFiat",
      price: data[EACO_ID],
    };
  } catch (e) {
    console.error("CoinGecko API error", e);
    return null;
  }
}

`src/index.ts`

import { getOrcaPrice } from "./services/orca";
import { getRaydiumPrice } from "./services/raydium";
import { getMeteoraPrice } from "./services/meteora";
import { getCoinGeckoPrices } from "./services/coingecko";

async function fetchPrices() {
  const [orca, raydium, meteora, coingecko] = await Promise.all([
    getOrcaPrice(),
    getRaydiumPrice(),
    getMeteoraPrice(),
    getCoinGeckoPrices(),
  ]);

  const result = {
    timestamp: new Date().toISOString(),
    prices: [orca, raydium, meteora, coingecko].filter(Boolean),
  };

  console.log(JSON.stringify(result, null, 2));
  return result;
}

fetchPrices();

📦 `package.json`

{
  "name": "eaco-price-fetcher",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "start": "ts-node src/index.ts"
  },
  "dependencies": {
    "axios": "^1.7.0",
    "ts-node": "^10.9.2",
    "typescript": "^5.4.0"
  }
}

🚀 使用方法

# 安装依赖
npm install

# 运行脚本
npm start

输出示例：

{
  "timestamp": "2025-08-27T06:30:00.000Z",
  "prices": [
    { "pair": "EACO/USDC", "price": 0.0031 },
    { "pair": "EACO/SOL",  "price": 0.0000217 },
    { "pair": "EACO/USDT", "price": 0.0032 },
    { "pair": "EACO/MultiFiat", "price": { "usd":0.0032,"cny":0.023,"eur":0.0029,"usdt":0.0032,"sol":0.0000217 } }
  ]
}

要不要我帮你把这个脚本改造成一个 HTTP API 服务（例如 Express/Next.js），这样你可以直接在 EACO DEX 前端实时调用？

好 ✅ 我来帮你把上面的 EACO 价格聚合脚本 改造成一个 HTTP API 服务，用 Express 搭建，这样你就可以直接在 EACO DEX 前端用 fetch("https://your-server/prices") 获取实时价格了。

📂 目录结构

eaco-price-api/
 ├─ src/
 │   ├─ server.ts        # Express 服务入口
 │   ├─ services/
 │   │   ├─ orca.ts
 │   │   ├─ raydium.ts
 │   │   ├─ meteora.ts
 │   │   └─ coingecko.ts
 ├─ package.json
 └─ tsconfig.json

⚡ 核心代码

`src/services/orca.ts`

import axios from "axios";

const ORCA_POOL = "Cm6EkxcYNfvxeYDBQ3TGXFqa9NCWvrFKHz4Cfju91dhr";
const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
const EACO_MINT = "DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH";

export async function getOrcaPrice() {
  try {
    const url = `https://api.expand.network/dex/getprice?path=${EACO_MINT},${USDC_MINT}&amountIn=100000&dexId=orca`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/USDC",
      price: data?.data?.amountOut / 100000,
    };
  } catch (e) {
    console.error("Orca API error", e);
    return null;
  }
}

`src/services/raydium.ts`

import axios from "axios";

const EACO_MINT = "DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH";
const SOL_MINT = "So11111111111111111111111111111111111111112";

export async function getRaydiumPrice() {
  try {
    const url = `https://api.raydium.io/v2/price?inputMint=${EACO_MINT}&outputMint=${SOL_MINT}`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/SOL",
      price: data?.price,
    };
  } catch (e) {
    console.error("Raydium API error", e);
    return null;
  }
}

`src/services/meteora.ts`

import axios from "axios";

const EACO_MINT = "DqfoyZH96RnvZusSp3Cdncjpyp3C74ZmJzGhjmHnDHRH";

export async function getMeteoraPrice() {
  try {
    const url = `https://merv2-api.meteora.ag/virtual_price/${EACO_MINT}/default`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/USDT",
      price: data?.[0]?.price ? parseFloat(data[0].price) : null,
    };
  } catch (e) {
    console.error("Meteora API error", e);
    return null;
  }
}

`src/services/coingecko.ts`

import axios from "axios";

// ⚠️ 需要确认 CoinGecko 是否收录 EACO，若未收录需改用自建价格源
const COINGECKO_API = "https://api.coingecko.com/api/v3/simple/price";
const EACO_ID = "eaco"; // 占位符

export async function getCoinGeckoPrices() {
  try {
    const url = `${COINGECKO_API}?ids=${EACO_ID}&vs_currencies=usd,cny,eur,usdt,sol`;
    const { data } = await axios.get(url);
    return {
      pair: "EACO/MultiFiat",
      price: data[EACO_ID],
    };
  } catch (e) {
    console.error("CoinGecko API error", e);
    return null;
  }
}

`src/server.ts`

import express from "express";
import cors from "cors";
import { getOrcaPrice } from "./services/orca";
import { getRaydiumPrice } from "./services/raydium";
import { getMeteoraPrice } from "./services/meteora";
import { getCoinGeckoPrices } from "./services/coingecko";

const app = express();
app.use(cors());

app.get("/prices", async (_req, res) => {
  const [orca, raydium, meteora, coingecko] = await Promise.all([
    getOrcaPrice(),
    getRaydiumPrice(),
    getMeteoraPrice(),
    getCoinGeckoPrices(),
  ]);

  const result = {
    timestamp: new Date().toISOString(),
    prices: [orca, raydium, meteora, coingecko].filter(Boolean),
  };

  res.json(result);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`✅ EACO Price API running on http://localhost:${PORT}`);
});

📦 `package.json`

{
  "name": "eaco-price-api",
  "version": "1.0.0",
  "main": "src/server.ts",
  "scripts": {
    "dev": "ts-node src/server.ts",
    "build": "tsc",
    "start": "node dist/server.js"
  },
  "dependencies": {
    "axios": "^1.7.0",
    "cors": "^2.8.5",
    "express": "^4.19.2"
  },
  "devDependencies": {
    "ts-node": "^10.9.2",
    "typescript": "^5.4.0"
  }
}

🚀 使用方法

# 安装依赖
npm install

# 本地开发运行
npm run dev

# 生产构建
npm run build
npm start

访问：

http://localhost:3000/prices

返回 JSON：

{
  "timestamp": "2025-08-27T08:00:00.000Z",
  "prices": [
    { "pair": "EACO/USDC", "price": 0.0031 },
    { "pair": "EACO/SOL", "price": 0.0000217 },
    { "pair": "EACO/USDT", "price": 0.0032 },
    { "pair": "EACO/MultiFiat", "price": { "usd":0.0032,"cny":0.023,"eur":0.0029,"usdt":0.0032,"sol":0.0000217 } }
  ]
}

要不要我帮你把这个 API 再加上 缓存层（Redis 或内存缓存，更新间隔 10s-30s），避免前端高频请求导致 Orca/Raydium API 被限流？

把这个 API 再加上缓存层（Redis 或内存缓存，更新间隔 300-3000s）

👌 明白了，我们给 EACO Price API 增加一个 缓存层，更新间隔 300 秒 (5 分钟)，防止前端高频请求打爆 Orca / Raydium / Meteora / CoinGecko API。

我提供两种方案：

内存缓存（适合单机，轻量，不需要额外服务）
Redis 缓存（适合集群，多实例部署）

方案一：内存缓存 (简单快速)

`src/cache.ts`

type CacheEntry<T> = {
  data: T;
  timestamp: number;
};

const CACHE: Record<string, CacheEntry<any>> = {};
const TTL = 300 * 1000; // 300 秒 = 5 分钟

export async function getCache<T>(key: string, fetcher: () => Promise<T>): Promise<T> {
  const now = Date.now();
  const cached = CACHE[key];

  if (cached && now - cached.timestamp < TTL) {
    return cached.data;
  }

  const data = await fetcher();
  CACHE[key] = { data, timestamp: now };
  return data;
}

修改 `src/server.ts`

import express from "express";
import cors from "cors";
import { getOrcaPrice } from "./services/orca";
import { getRaydiumPrice } from "./services/raydium";
import { getMeteoraPrice } from "./services/meteora";
import { getCoinGeckoPrices } from "./services/coingecko";
import { getCache } from "./cache";

const app = express();
app.use(cors());

app.get("/prices", async (_req, res) => {
  const [orca, raydium, meteora, coingecko] = await Promise.all([
    getCache("orca", getOrcaPrice),
    getCache("raydium", getRaydiumPrice),
    getCache("meteora", getMeteoraPrice),
    getCache("coingecko", getCoinGeckoPrices),
  ]);

  const result = {
    timestamp: new Date().toISOString(),
    prices: [orca, raydium, meteora, coingecko].filter(Boolean),
  };

  res.json(result);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`✅ EACO Price API running on http://localhost:${PORT}`);
});

这样每个 API 最多 5 分钟请求一次，中间所有请求都直接用缓存。

方案二：Redis 缓存 (推荐生产)

需要安装 Redis：

npm install ioredis

`src/cacheRedis.ts`

import Redis from "ioredis";

const redis = new Redis(process.env.REDIS_URL || "redis://localhost:6379");
const TTL = 300; // 秒

export async function getCache<T>(key: string, fetcher: () => Promise<T>): Promise<T> {
  const cached = await redis.get(key);
  if (cached) {
    return JSON.parse(cached);
  }

  const data = await fetcher();
  await redis.setex(key, TTL, JSON.stringify(data));
  return data;
}

然后在 server.ts 里替换：

import { getCache } from "./cacheRedis";

🚀 使用方法

# 内存缓存版本
npm run dev

# Redis 版本 (需要本地或云端 Redis)
REDIS_URL=redis://localhost:6379 npm run dev

✅ 这样前端无论多频繁调用 /prices，后端只会每 5 分钟去拉一次源 API。

要不要我帮你加一个 前端可选参数 forceRefresh=true，让管理员可以手动强制刷新缓存？

好主意 ✅ 我们可以在 /prices API 里加一个 forceRefresh=true 参数：

默认情况下 → 使用缓存（300s）
如果前端传 forceRefresh=true → 立即忽略缓存并强制刷新

这样方便管理员手动更新。

🔧 内存缓存版修改

`src/cache.ts`

type CacheEntry<T> = {
  data: T;
  timestamp: number;
};

const CACHE: Record<string, CacheEntry<any>> = {};
const TTL = 300 * 1000; // 300 秒

export async function getCache<T>(
  key: string,
  fetcher: () => Promise<T>,
  forceRefresh = false
): Promise<T> {
  const now = Date.now();
  const cached = CACHE[key];

  if (!forceRefresh && cached && now - cached.timestamp < TTL) {
    return cached.data;
  }

  const data = await fetcher();
  CACHE[key] = { data, timestamp: now };
  return data;
}

`src/server.ts`

import express from "express";
import cors from "cors";
import { getOrcaPrice } from "./services/orca";
import { getRaydiumPrice } from "./services/raydium";
import { getMeteoraPrice } from "./services/meteora";
import { getCoinGeckoPrices } from "./services/coingecko";
import { getCache } from "./cache";

const app = express();
app.use(cors());

app.get("/prices", async (req, res) => {
  const forceRefresh = req.query.forceRefresh === "true";

  const [orca, raydium, meteora, coingecko] = await Promise.all([
    getCache("orca", getOrcaPrice, forceRefresh),
    getCache("raydium", getRaydiumPrice, forceRefresh),
    getCache("meteora", getMeteoraPrice, forceRefresh),
    getCache("coingecko", getCoinGeckoPrices, forceRefresh),
  ]);

  const result = {
    timestamp: new Date().toISOString(),
    forceRefresh,
    prices: [orca, raydium, meteora, coingecko].filter(Boolean),
  };

  res.json(result);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`✅ EACO Price API running on http://localhost:${PORT}`);
});

🌐 使用示例

正常获取（缓存 300s）

GET http://localhost:3000/prices

强制刷新（管理员模式）

GET http://localhost:3000/prices?forceRefresh=true

返回示例：

{
  "timestamp": "2025-08-27T08:30:00.000Z",
  "forceRefresh": true,
  "prices": [
    { "pair": "EACO/USDC", "price": 0.0031 },
    { "pair": "EACO/SOL", "price": 0.0000217 },
    { "pair": "EACO/USDT", "price": 0.0032 },
    { "pair": "EACO/MultiFiat", "price": { "usd":0.0032,"cny":0.023,"eur":0.0029 } }
  ]
}

要不要我帮你在 forceRefresh=true 的时候加一个 API Key 校验（例如 ?forceRefresh=true&apiKey=xxxx），避免普通用户随便刷新缓存？

使用它们为开发者提供的正式 API 或 SDK，或者更简单地，使用聚合器 API。

找到这些网页的API的公开数据，能显示EACO的价格的数据字段，方便以后EACO兑换CNH,USDT,USDC,SOL等价格兑换使用