feat: add subgraph for token converters

subgraphs/protocol-reserve/README.md

@@ -0,0 +1,3 @@
+# Protocol Reserve Subgraph
+
+This subgraph indexes events for the Venus Protocol Reserve and related contracts such as the Token Converters

subgraphs/protocol-reserve/config/index.ts

@@ -0,0 +1,68 @@
+import mainnetIlDeployments from '@venusprotocol/isolated-pools/deployments/bscmainnet_addresses.json';
+import chapelIlDeployments from '@venusprotocol/isolated-pools/deployments/bsctestnet_addresses.json';
+import mainnetDeployments from '@venusprotocol/protocol-reserve/deployments/bscmainnet_addresses.json';
+import chapelDeployments from '@venusprotocol/protocol-reserve/deployments/bsctestnet_addresses.json';
+import fs from 'fs';
+import Mustache from 'mustache';
+
+export const getNetwork = () => {
+  const supportedNetworks = ['chapel', 'bsc', 'docker'] as const;
+  const network = process.env.NETWORK;
+  // @ts-expect-error network env var is unknown here
+  if (!supportedNetworks.includes(network)) {
+    throw new Error(`NETWORK env var must be set to one of ${supportedNetworks}`);
+  }
+  return network as (typeof supportedNetworks)[number];
+};
+
+const main = () => {
+  const network = getNetwork();
+  const config = {
+    docker: {
+      network: 'hardhat',
+      converterNetworkAddress: '0x0000000000000000000000000000000000000000',
+      btcbPrimeConverterAddress: '0x0000000000000000000000000000000000000000',
+      ethPrimeConverterAddress: '0x0000000000000000000000000000000000000000',
+      riskFundConverterAddress: '0x0000000000000000000000000000000000000000',
+      usdcPrimeConverterAddress: '0x0000000000000000000000000000000000000000',
+      usdtPrimeConverterAddress: '0x0000000000000000000000000000000000000000',
+      xvsVaultConverterAddress: '0x0000000000000000000000000000000000000000',
+      riskFundAddress: '0x0000000000000000000000000000000000000000',
+      startBlock: 0,
+    },
+    chapel: {
+      network: 'chapel',
+      converterNetworkAddress: chapelDeployments.addresses.ConverterNetwork,
+      btcbPrimeConverterAddress: chapelDeployments.addresses.BTCBPrimeConverter,
+      ethPrimeConverterAddress: chapelDeployments.addresses.ETHPrimeConverter,
+      riskFundConverterAddress: chapelDeployments.addresses.RiskFundConverter,
+      usdcPrimeConverterAddress: chapelDeployments.addresses.USDCPrimeConverter,
+      usdtPrimeConverterAddress: chapelDeployments.addresses.USDTPrimeConverter,
+      xvsVaultConverterAddress: chapelDeployments.addresses.XVSVaultConverter,
+      riskFundAddress: chapelIlDeployments.addresses.RiskFund,
+      startBlock: '36750497',
+    },
+    bsc: {
+      network: 'bsc',
+      converterNetworkAddress: mainnetDeployments.addresses.ConverterNetwork,
+      btcbPrimeConverterAddress: mainnetDeployments.addresses.BTCBPrimeConverter,
+      ethPrimeConverterAddress: mainnetDeployments.addresses.ETHPrimeConverter,
+      riskFundConverterAddress: mainnetDeployments.addresses.RiskFundConverter,
+      usdcPrimeConverterAddress: mainnetDeployments.addresses.USDCPrimeConverter,
+      usdtPrimeConverterAddress: mainnetDeployments.addresses.USDTPrimeConverter,
+      xvsVaultConverterAddress: mainnetDeployments.addresses.XVSVaultConverter,
+      riskFundAddress: mainnetIlDeployments.addresses.RiskFund,
+      startBlock: '32659400',
+    },
+  };
+
+  const yamlTemplate = fs.readFileSync('template.yaml', 'utf8');
+  const yamlOutput = Mustache.render(yamlTemplate, config[network]);
+  fs.writeFileSync('subgraph.yaml', yamlOutput);
+
+  const configTemplate = fs.readFileSync('src/constants/config-template', 'utf8');
+  const tsOutput = Mustache.render(configTemplate, config[network]);
+  fs.writeFileSync('src/constants/config.ts', tsOutput);
+};
+
+main();

subgraphs/protocol-reserve/matchstick.yaml

@@ -0,0 +1 @@
+libsFolder: ../../node_modules/

subgraphs/protocol-reserve/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "protocol-reserve-subgraph",
+  "version": "0.0.0",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/VenusProtocol/subgraphs",
+    "directory": "subgraphs/isolated-pools"
+  },
+  "files": [
+    "generated"
+  ],
+  "scripts": {
+    "codegen": "npx graph codegen",
+    "create:docker": "npx graph create venusprotocol/venus-protocol-reserve --node http://graph-node:8020/",
+    "build:docker": "npx graph build --ipfs http://ipfs:5001",
+    "build:bsc": "graph build --ipfs https://api.thegraph.com/ipfs/ ",
+    "deploy:integration": "graph deploy venusprotocol/venus-protocol-reserve --ipfs http://localhost:5001 --node http://127.0.0.1:8020/",
+    "deploy:docker": "yarn prepare:docker && npx graph deploy venusprotocol/venus-protocol-reserve --ipfs http://ipfs:5001 --node http://graph-node:8020/ --version-label ci",
+    "deploy:chapel": "yarn prepare:chapel && graph deploy venusprotocol/venus-protocol-reserve-chapel --ipfs https://api.thegraph.com/ipfs/ --node https://api.thegraph.com/deploy/",
+    "deploy:bsc": "yarn prepare:bsc && graph deploy venusprotocol/venus-protocol-reserve --ipfs https://api.thegraph.com/ipfs/ --node https://api.thegraph.com/deploy/",
+    "prepare:docker": "NETWORK=docker npx ts-node config/index.ts",
+    "prepare:chapel": "NETWORK=chapel npx ts-node config/index.ts",
+    "prepare:bsc": "NETWORK=bsc npx ts-node config/index.ts",
+    "generate-subgraph-types": "rm -rf /subgraph-client/.graphclient && npx graphclient build --dir ./subgraph-client",
+    "pretty": "prettier —-write '**/*.ts'",
+    "test": "yarn prepare:docker && graph test",
+    "test:integration": "npx hardhat test tests/integration/index.ts --network localhost"
+  },
+  "devDependencies": {
+    "apollo-fetch": "^0.7.0",
+    "urql": "^3.0.3",
+    "venus-subgraph-utils": "0.0.0"
+  }
+}

subgraphs/protocol-reserve/schema.graphql

@@ -0,0 +1,38 @@
+enum ConversionAccessibility {
+    NONE
+    ALL
+    ONLY_FOR_CONVERTERS
+    ONLY_FOR_USERS
+}
+
+"""
+Converter Network entity
+"""
+type ConverterNetwork @entity {
+    id: ID!
+    tokenConverters: [TokenConverter!]! @derivedFrom(field: "converterNetwork")
+}
+
+"""
+Token Converter entity
+"""
+type TokenConverter @entity {
+    id: ID!
+    converterNetwork: ConverterNetwork
+    destinationAddress: Bytes!
+    baseAsset: Bytes!
+    configs: [TokenConverterConfig!]! @derivedFrom(field: "tokenConverter")
+    paused: Boolean!
+}
+
+"""
+Token Converter Config
+"""
+type TokenConverterConfig @entity {
+    id: ID!
+    tokenConverter: TokenConverter!
+    tokenAddressIn: Bytes!
+    tokenAddressOut: Bytes!
+    incentive: BigInt!
+    access: ConversionAccessibility!
+}

subgraphs/protocol-reserve/src/constants/addresses.ts

@@ -0,0 +1,12 @@
+import { Address } from '@graphprotocol/graph-ts';
+
+import {
+  converterNetworkAddress as converterNetworkAddressString,
+  riskFundAddress as riskFundAddressString,
+  riskFundConverterAddress as riskFundConverterAddressString,
+} from './config';
+
+export const converterNetworkAddress = Address.fromString(converterNetworkAddressString);
+export const riskFundConverterAddress = Address.fromString(riskFundConverterAddressString);
+export const riskFundAddress = Address.fromString(riskFundAddressString);
+export const nullAddress = Address.fromString('0x0000000000000000000000000000000000000000');

subgraphs/protocol-reserve/src/constants/config-template

@@ -0,0 +1,6 @@
+// Use yarn prepare commands to generate config typescript file per env
+
+export const converterNetworkAddress = '{{ converterNetworkAddress }}';
+export const riskFundConverterAddress = '{{ riskFundConverterAddress }}';
+export const riskFundAddress = '{{ riskFundAddress }}';
+

subgraphs/protocol-reserve/src/constants/index.ts

@@ -0,0 +1,12 @@
+import { BigDecimal, BigInt } from '@graphprotocol/graph-ts';
+
+export const NOT_AVAILABLE_BIG_INT = BigInt.fromString('-1');
+export const NOT_AVAILABLE_BIG_DECIMAL = BigDecimal.fromString('-1');
+
+export const zeroBigDecimal = BigDecimal.fromString('0');
+export const zeroBigInt32 = BigInt.fromString('0');
+export const oneBigInt = BigInt.fromString('1');
+
+export const mantissaFactor = 18;
+
+export const ConversionAccessibility = ['NONE', 'ALL', 'ONLY_FOR_CONVERTERS', 'ONLY_FOR_USERS'];

subgraphs/protocol-reserve/src/mappings/converterNetwork.ts

@@ -0,0 +1,19 @@
+import {
+  ConverterAdded,
+  ConverterRemoved,
+} from '../../generated/ConverterNetwork/ConverterNetwork';
+import { getOrCreateConverterNetwork, getOrCreateTokenConverter } from '../operations/getOrCreate';
+import { getConverterNetworkId } from '../utilities/ids';
+
+export function handleConverterAdded(event: ConverterAdded): void {
+  getOrCreateConverterNetwork(event.address);
+  const tokenConverter = getOrCreateTokenConverter(event.params.converter);
+  tokenConverter.converterNetwork = getConverterNetworkId(event.address);
+  tokenConverter.save();
+}
+
+export function handleConverterRemoved(event: ConverterRemoved): void {
+  const tokenConverter = getOrCreateTokenConverter(event.params.converter);
+  tokenConverter.converterNetwork = null;
+  tokenConverter.save();
+}

subgraphs/protocol-reserve/src/mappings/tokenConverter.ts

@@ -0,0 +1,46 @@
+import {
+  BaseAssetUpdated,
+  ConversionConfigUpdated,
+  ConversionPaused,
+  ConversionResumed,
+  ConverterNetworkAddressUpdated,
+  DestinationAddressUpdated,
+} from '../../generated/BTCBPrimeConverter/TokenConverter';
+import { getOrCreateTokenConverter } from '../operations/getOrCreate';
+import { updateOrCreateTokenConverterConfig } from '../operations/updateOrCreate';
+import { getConverterNetworkId } from '../utilities/ids';
+
+export function handleConversionConfigUpdated(event: ConversionConfigUpdated): void {
+  getOrCreateTokenConverter(event.address);
+  updateOrCreateTokenConverterConfig(event.address, event.params);
+}
+
+export function handleConversionPaused(event: ConversionPaused): void {
+  const tokenConverter = getOrCreateTokenConverter(event.address);
+  tokenConverter.paused = true;
+  tokenConverter.save();
+}
+
+export function handleConversionResumed(event: ConversionResumed): void {
+  const tokenConverter = getOrCreateTokenConverter(event.address);
+  tokenConverter.paused = false;
+  tokenConverter.save();
+}
+
+export function handleConverterNetworkAddressUpdated(event: ConverterNetworkAddressUpdated): void {
+  const tokenConverter = getOrCreateTokenConverter(event.address);
+  tokenConverter.converterNetwork = getConverterNetworkId(event.params.converterNetwork);
+  tokenConverter.save();
+}
+
+export function handleDestinationAddressUpdated(event: DestinationAddressUpdated): void {
+  const tokenConverter = getOrCreateTokenConverter(event.address);
+  tokenConverter.destinationAddress = event.params.destinationAddress;
+  tokenConverter.save();
+}
+
+export function handleBaseAssetUpdated(event: BaseAssetUpdated): void {
+  const tokenConverter = getOrCreateTokenConverter(event.address);
+  tokenConverter.baseAsset = event.params.newBaseAsset;
+  tokenConverter.save();
+}

subgraphs/protocol-reserve/src/operations/create.ts

@@ -0,0 +1,42 @@
+import { Address } from '@graphprotocol/graph-ts';
+
+import { TokenConverter as TokenConverterContract } from '../../generated/BTCBPrimeConverter/TokenConverter';
+import { RiskFund } from '../../generated/ConverterNetwork/RiskFund';
+import { TokenConverter, TokenConverterConfig } from '../../generated/schema';
+import { riskFundAddress, riskFundConverterAddress } from '../constants/addresses';
+import { valueOrNotAvailableAddressIfReverted } from '../utilities';
+import { getTokenConverterConfigId, getTokenConverterId } from '../utilities/ids';
+
+export function createTokenConverter(tokenConverterAddress: Address): TokenConverter {
+  const tokenConverterContract = TokenConverterContract.bind(tokenConverterAddress);
+  const tokenConverter = new TokenConverter(getTokenConverterId(tokenConverterAddress));
+  tokenConverter.destinationAddress = tokenConverterContract.destinationAddress();
+
+  if (tokenConverterAddress.equals(riskFundConverterAddress)) {
+    const riskFund = RiskFund.bind(riskFundAddress);
+    tokenConverter.baseAsset = valueOrNotAvailableAddressIfReverted(
+      riskFund.try_convertibleBaseAsset(),
+    );
+  } else {
+    tokenConverter.baseAsset = valueOrNotAvailableAddressIfReverted(
+      tokenConverterContract.try_baseAsset(),
+    );
+  }
+  tokenConverter.paused = false;
+  tokenConverter.save();
+  return tokenConverter;
+}
+
+export function createTokenConverterConfig(
+  tokenConverterAddress: Address,
+  tokenAddressIn: Address,
+  tokenAddressOut: Address,
+): TokenConverterConfig {
+  const tokenConverterConfig = new TokenConverterConfig(
+    getTokenConverterConfigId(tokenConverterAddress, tokenAddressIn, tokenAddressOut),
+  );
+  tokenConverterConfig.tokenConverter = getTokenConverterId(tokenConverterAddress);
+  tokenConverterConfig.tokenAddressIn = tokenAddressIn;
+  tokenConverterConfig.tokenAddressOut = tokenAddressOut;
+  return tokenConverterConfig;
+}

subgraphs/protocol-reserve/src/operations/get.ts

@@ -0,0 +1,20 @@
+import { Address } from '@graphprotocol/graph-ts';
+
+import { TokenConverter, TokenConverterConfig } from '../../generated/schema';
+import { getTokenConverterConfigId, getTokenConverterId } from '../utilities/ids';
+
+export function getTokenConverter(tokenConverterAddress: Address): TokenConverter | null {
+  const id = getTokenConverterId(tokenConverterAddress);
+  const tokenConverter = TokenConverter.load(id);
+  return tokenConverter;
+}
+
+export function getTokenConverterConfig(
+  tokenConverterAddress: Address,
+  tokenAddressIn: Address,
+  tokenAddressOut: Address,
+): TokenConverterConfig | null {
+  const id = getTokenConverterConfigId(tokenConverterAddress, tokenAddressIn, tokenAddressOut);
+  const tokenConverterConfig = TokenConverterConfig.load(id);
+  return tokenConverterConfig;
+}

subgraphs/protocol-reserve/src/operations/getOrCreate.ts

@@ -0,0 +1,59 @@
+import { Address } from '@graphprotocol/graph-ts';
+
+import { ConverterNetwork, TokenConverter, TokenConverterConfig } from '../../generated/schema';
+import { getConverterNetworkId } from '../utilities/ids';
+import { createTokenConverter, createTokenConverterConfig } from './create';
+import { getTokenConverter, getTokenConverterConfig } from './get';
+
+/**
+ * TokenConverters are hardcoded in the subgraph definition
+ *
+ * @param tokenConverterAddress
+ * @returns TokenConverter Entity
+ */
+export function getOrCreateTokenConverter(tokenConverterAddress: Address): TokenConverter {
+  let tokenConverter = getTokenConverter(tokenConverterAddress);
+
+  if (!tokenConverter) {
+    tokenConverter = createTokenConverter(tokenConverterAddress);
+  }
+
+  return tokenConverter;
+}
+
+/**
+ * ConverterNetwork is hardcoded in the subgraph definition
+ *
+ * @param converterNetworkAddress
+ * @returns
+ */
+export function getOrCreateConverterNetwork(converterNetworkAddress: Address): ConverterNetwork {
+  let converterNetwork = ConverterNetwork.load(getConverterNetworkId(converterNetworkAddress));
+
+  if (!converterNetwork) {
+    converterNetwork = new ConverterNetwork(getConverterNetworkId(converterNetworkAddress));
+  }
+
+  return converterNetwork;
+}
+
+export function getOrCreateTokenConverterConfig(
+  tokenConverterAddress: Address,
+  tokenAddressIn: Address,
+  tokenAddressOut: Address,
+): TokenConverterConfig {
+  let tokenConverterConfig = getTokenConverterConfig(
+    tokenConverterAddress,
+    tokenAddressIn,
+    tokenAddressOut,
+  );
+
+  if (!tokenConverterConfig) {
+    tokenConverterConfig = createTokenConverterConfig(
+      tokenConverterAddress,
+      tokenAddressIn,
+      tokenAddressOut,
+    );
+  }
+  return tokenConverterConfig;
+}

subgraphs/protocol-reserve/src/operations/updateOrCreate.ts

@@ -0,0 +1,19 @@
+import { Address } from '@graphprotocol/graph-ts';
+
+import { ConversionConfigUpdated__Params } from '../../generated/BTCBPrimeConverter/TokenConverter';
+import { ConversionAccessibility } from '../constants/index';
+import { getOrCreateTokenConverterConfig } from './getOrCreate';
+
+export function updateOrCreateTokenConverterConfig(
+  tokenConverterAddress: Address,
+  params: ConversionConfigUpdated__Params,
+): void {
+  const tokenConverterConfig = getOrCreateTokenConverterConfig(
+    tokenConverterAddress,
+    params.tokenAddressIn,
+    params.tokenAddressOut,
+  );
+  tokenConverterConfig.incentive = params.newIncentive;
+  tokenConverterConfig.access = ConversionAccessibility[params.newAccess];
+  tokenConverterConfig.save();
+}