feat: add RPC calls and checks

[rossgalloway]

This supersedes #479

Implemented RPC contract reads into the site using the Viem Ethereum library. There are 2 features currently working.

1. Verifying Contract Addresses

All the V3 contract addresses shown on the V3 addresses page are now checked against from their respective registry smart contracts.

There is a single constants file with ENS names and addresses where addresses should be kept updated. A new github workflow is part of this PR, which runs a script to check the constants file against on-chain addresses every night at midnight. If the check fails, a new issue is posted to the repo issues board and a component on the addresses page gives a warning.

On initial site load:

• Protocol Address Provider and Role Manager are resolved from their ENS names and checked against the constants file.
• Protocol Periphery Addresses are queried from the Protocol Address Provider that was just resolved. They are checked against the constants file and their ENS names (if they have them).
• Release Registry Addresses are queried from the Release Registry that is retrieved from the Protocol Address Provider. They are checked against the constants file and their ENS names (if they have them).
• The most recent Vault Original is queried from the Vault Factory that was just pulled from the Release Registry. It is checked against the constants file.
• Yearn Specific Contract addresses are pulled from the RoleManager. They are checked against the constants file and their ENS names (if they have them).

These contract addresses and the checks are then served as context to the app.

On initial Address page load:

The checks are consumed by an <AddressCheck> component that reads the checks from the context and posts a message about whether the checks passed or failed. If they failed then the failed check information is posted to the console.

Where addresses are needed, <ContractAddress> components consume static address data from the constants file and display a link with the Address as the text and the hyperlink to the etherscan page. It takes the following argument:

• contractName which is the path to the data you want to read from the constants file.

The component is used like this:

<ContractAddress contractName = {['topLevel', 'protocolAddressProvider']} />

The shape of the data object is:

type ContractAddresses = {
  topLevel: TopLevelAddresses
  protocolPeriphery: ProtocolPeripheryAddresses
  releaseRegistry: ReleaseDataMap
  yearnV3: YearnAddresses
  yfiTokenContracts: YfiTokenContracts
  veYfiContracts: VeYfiContracts
}

type TopLevelAddresses = {
  v3ProtocolAddressProvider: `0x${string}`
  v3ReleaseRegistry: `0x${string}`
  v3RoleManager: `0x${string}`
}

type ProtocolPeripheryAddresses = {
  router: `0x${string}` | undefined
  aprOracle: `0x${string}` | undefined
  commonReportTrigger: `0x${string}` | undefined
  roleManagerFactory: `0x${string}` | undefined
}

type ReleaseDataMap = {
  latestRelease: string
  [releaseNumber: string]: ReleaseData | string
}
// contains array of:
type ReleaseData = {
  vaultOriginal: string
  factory: string
  tokenizedStrategy: string
}

type YearnAddresses = {
  yearnBrain: `0x${string}` | undefined
  yearnDaddy: `0x${string}` | undefined
  yearnAccountant: `0x${string}` | undefined
  yearnDebtAllocator: `0x${string}` | undefined
  yearnRegistry: `0x${string}` | undefined
}

2. Make arbitrary contract call reads in docs

You can make RPC calls to read contract data from on-chain sources from within the docs. You can add the information for all the read calls you want within the front-matter of a markdown document. Front-matter is metadata that docusaurus reads when serving pages.

To make a blockchain call you need to structure your data in the following format at the top of the markdown file:

---
rpcCalls:

  - name: 'dYFI Redemption' <-- descriptive name of contract to be called for use in component
    chain: '1' <--chainID
    address: '0x7dC3A74F0684fc026f9163C6D5c3C99fda2cf60a' <--the contract address
    abiName: 'dyfiRedemptionABI' <--name of exported ABI object from src/ethereum/ABIs
    methods:  
      - 'discount' <-- name of call (if no arguments needed)
      - 'get_latest_price'
      - name: 'eth_required' <-- name of call (if arguments are needed)
        args: ['1000000000000000000'] <--comma separated arguments of call as an array (square brackets)

  - name: 'YFI token'
    chain: '1'
    address: '0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e'
    abiName: 'yfiTokenABI'
    methods:
      - totalSupply
      - symbol
---

• Each element in rpcCalls creates an object that is exported from the front-matter.
• Each object can contain calls to different functions in the same contract if you add them into the methods field.
  • If the method doesn't require args (the function doesn't require any input) then you only need to list the name. This is the name you see on etherscan, without the number.
  • If the method does require an argument then you need to add it with a name parameter and an args parameter, with the values for the arguments separated by commas and in square brackets.

When adding a new contract to call, you need to add the ABI to "src/ethereum/ABIs". Create a new typescript file with the name of your ABI. The convention is to name it in camelCase and end it with ABI (i.e. yfiTokenABI.ts). Then paste the ABI into the file (you can copy it from etherscan. It is in the contract->code section.). You need to export it and add as const at the end.

// src/ethereum/ABIs/yourContractABI.ts
export const yourContractABI = [
    {
    // abi data here
    }
] as const

You then need to export this element from the index.ts file in the same directory. Add a line exporting your ABI as shown below.

export * from './yourContractABI'

To display the data from the calls, use the component. It takes the following arguments:

• contractName which reads the name field in the rpcCall defined in the front-matter
• methodName which reads from the methods in the rpcCall defined in the front-matter
• decimals which is an optional argument to format your output to display with human readable decimals. It should be wrapped in curly brackets {}.

The current redemption discount is: <ContractData contractName='dYFI Redemption' methodName='discount' decimals={18} />

[vercel]

The latest updates on your projects. Learn more about Vercel for Git ↗︎

Name	Status	Preview	Comments	Updated (UTC)
yearn-docs	✅ Ready (Inspect)	Visit Preview	💬 Add feedback	Dec 12, 2024 8:44pm