External APIs and IPFS

import axios from "axios";
import moment from "moment";

run(dataSource, new TypeormDatabase(), async (ctx) => {
  const prices: TokenPrice[] = [];

  for (let block of ctx.blocks) {
    // Fetch the historical price once per block and attach it to
    // whatever entities you derive from the block's data.
    const price = await getTokenPriceByDate(block.header.timestamp);

    prices.push(
      new TokenPrice({
        id: `${block.header.height}`,
        block: block.header.height,
        price,
      })
    );
  }

  await ctx.store.save(prices);
});

async function getTokenPriceByDate(timestamp: number): Promise<number> {
  const formatted = moment(new Date(timestamp).toISOString()).format(
    "DD-MM-YYYY"
  );
  const res = await axios.get(
    `https://api.coingecko.com/api/v3/coins/ethereum/history?date=${formatted}&localization=false`
  );
  return res.data.market_data.current_price.usd;
}

import Axios from "axios";
import https from "https";

// Use a dedicated gateway for production
export const BASE_URL = "https://your-dedicated-gateway.ipfs.io/ipfs/";

export const api = Axios.create({
  baseURL: BASE_URL,
  headers: {
    "Content-Type": "application/json",
  },
  withCredentials: false,
  timeout: 5000,
  httpsAgent: new https.Agent({ keepAlive: true }),
});

import { createLogger } from "@subsquid/logger";

const log = createLogger("sqd:processor:ipfs");

export const fetchMetadata = async (cid: string): Promise<any | null> => {
  try {
    const { status, data } = await api.get(`${BASE_URL}/${cid}`);
    log.info(`[IPFS] ${status} CID: ${cid}`);

    if (status < 400) {
      return data;
    }
  } catch (e) {
    log.warn(`[IPFS] ERROR CID: ${cid} - ${(e as Error).message}`);
  }
  return null;
};

run(dataSource, new TypeormDatabase(), async (ctx) => {
  for (let block of ctx.blocks) {
    // Pull metadata URIs out of this block's decoded items,
    // then enrich each one:
    for (let { tokenId, tokenURI, cid } of extractMetadataRefs(block)) {

      // Fetch metadata from IPFS
      const metadata = await fetchMetadata(cid);

      if (metadata) {
        // Store the entity with its off-chain metadata
        await ctx.store.save(
          new Token({
            id: tokenId,
            uri: tokenURI,
            name: metadata.name,
            image: metadata.image,
            attributes: metadata.attributes,
          })
        );
      }
    }
  }
});