Connect Smart Contracts to Web2 API with Gelato Web3 Functions

import { Web3Function, Web3FunctionContext } from "@gelatonetwork/web3-functions-sdk";
import { Contract } from "ethers";
import ky from "ky";

const ORACLE_ABI = [
  "function lastUpdated() external view returns(uint256)",
  "function updatePrice(uint256)",
];

Web3Function.onRun(async (context: Web3FunctionContext) => {
  const provider = context.multiChainProvider.default();
  const oracleAddress = "0x71b9b0f6c999cbbb0fef9c92b80d54e4973214da";
  const oracle = new Contract(oracleAddress, ORACLE_ABI, provider);

  const lastUpdated = parseInt(await oracle.lastUpdated());
  const nextUpdateTime = lastUpdated + 300; // 5 min interval
  const timestamp = (await provider.getBlock("latest")).timestamp;
  if (timestamp < nextUpdateTime) return { canExec: false, message: "Too early" };

  const priceData = await ky
    .get("https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd")
    .json();
  const price = Math.floor(priceData["ethereum"].usd);

  return {
    canExec: true,
    callData: [{
      to: oracleAddress,
      data: oracle.interface.encodeFunctionData("updatePrice", [price])
    }],
  };
});

Web3Function.onRun(async (context) => {
  const gameId = context.userArgs.gameId ?? "Argentina_vs_France";
  const res = await axios.get(`https://www.thesportsdb.com/api/v1/json/3/searchevents.php?e=${gameId}`);
  const gameEvent = res.data.event[0];

  if (gameEvent.strStatus !== "Match Finished") 
    return { canExec: false, message: "Match not finished yet" };

  const BETTING_CONTRACT_ABI = ["function updateGameScore(string, uint16, uint16)"];
  const bettingInterface = new utils.Interface(BETTING_CONTRACT_ABI);

  return {
    canExec: true,
    callData: [{
      to: targetContract,
      data: bettingInterface.encodeFunctionData("updateGameScore", [
        gameId,
        parseInt(gameEvent.intHomeScore),
        parseInt(gameEvent.intAwayScore),
      ])
    }],
  };
});

// Generate text with OpenAI
const openai = new OpenAIApi(new Configuration({ apiKey: SECRETS_OPEN_AI_API_KEY }));
const response = await openai.createCompletion({ model: "text-davinci-003", prompt });
const text = response.data.choices[0].text;

// Upload metadata to IPFS
const storage = new Web3Storage({ token: WEB3_STORAGE_API_KEY });
const file = new File([JSON.stringify({ content: text })], "publication.json");
const cid = await storage.put([file]);
const contentURI = `https://${cid}.ipfs.w3s.link/publication.json`;

// Prepare callData for LensHub
const iface = new utils.Interface(lensHubAbi);
callDatas.push({ to: lensHubAddress, data: iface.encodeFunctionData("post", [postData]) });

// Check unrevealed NFTs
const nft = new Contract(nftAddress, NFT_ABI, provider);
const currentTokenId = (await nft.tokenIds()).toNumber();
if (currentTokenId === lastProcessedId) return { canExec: false };

// Generate image with Stable Diffusion API
const res = await fetch("https://stablediffusionapi.com/api/v3/text2img", {...});
const data = await res.json();
const imageUrl = data.output[0];

// Upload metadata to IPFS
const imageBlob = (await axios.get(imageUrl, { responseType: "blob" })).data;
const nftStorage = new NFTStorage({ token: nftStorageApiKey });
const metadata = await nftStorage.store({ image: new File([imageBlob], "nft.png") });

// Update contract
callDatas.push({
  to: nft.address,
  data: nft.interface.encodeFunctionData("revealNft", [tokenId, metadata.url]),
});