classic-ui/services/graph.js

431 lines
9.0 KiB
JavaScript

import { ApolloClient, InMemoryCache, gql } from '@apollo/client/core'
import {
_META,
GET_DEPOSITS,
GET_STATISTIC,
GET_REGISTERED,
GET_WITHDRAWALS,
GET_NOTE_ACCOUNTS,
GET_ENCRYPTED_NOTES
} from './queries'
const isEmptyArray = (arr) => !Array.isArray(arr) || !arr.length
const first = 1000
const link = ({ getContext }) => {
const { chainId } = getContext()
return CHAIN_GRAPH_URLS[chainId]
}
const CHAIN_GRAPH_URLS = {
1: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/mainnet-tornado-subgraph',
5: 'https://api.thegraph.com/subgraphs/name/tornadocash/goerli-tornado-subgraph',
10: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/optimism-tornado-subgraph',
56: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/bsc-tornado-subgraph',
100: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/xdai-tornado-subgraph',
137: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/matic-tornado-subgraph',
42161: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/arbitrum-tornado-subgraph',
43114: 'https://api.thegraph.com/subgraphs/name/tornadocash/avalanche-tornado-subgraph',
11155111: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/sepolia-tornado-subgraph'
}
const defaultOptions = {
query: {
fetchPolicy: 'no-cache',
errorPolicy: 'all'
}
}
const client = new ApolloClient({
uri: link,
credentials: 'omit',
cache: new InMemoryCache(),
defaultOptions
})
const registryClient = new ApolloClient({
uri: 'https://tornadocash-rpc.com/subgraphs/name/tornadocash/tornado-relayer-registry',
cache: new InMemoryCache(),
credentials: 'omit',
defaultOptions
})
async function getStatistic({ currency, amount, netId }) {
try {
const { data } = await client.query({
context: {
chainId: netId
},
query: gql(GET_STATISTIC),
variables: {
currency,
first: 10,
orderBy: 'index',
orderDirection: 'desc',
amount: String(amount)
}
})
if (!data) {
return {
lastSyncBlock: '',
events: []
}
}
const { deposits } = data
const lastSyncBlock = await getMeta({ netId })
const events = deposits
.map((e) => ({
timestamp: e.timestamp,
leafIndex: Number(e.index),
blockNumber: Number(e.blockNumber)
}))
.reverse()
const [lastEvent] = events.slice(-1)
return {
lastSyncBlock: lastEvent?.blockNumber >= lastSyncBlock ? lastEvent.blockNumber + 1 : lastSyncBlock,
events
}
} catch {
return {
lastSyncBlock: '',
events: []
}
}
}
async function getAllRegisters(fromBlock) {
try {
const relayers = await getRegisters(fromBlock)
if (!relayers) {
return { lastSyncBlock: '', events: [] }
}
const lastSyncBlock = await getRegisteredMeta()
return { lastSyncBlock, events: relayers }
} catch {
return { lastSyncBlock: '', events: [] }
}
}
async function getAllDeposits({ currency, amount, fromBlock, netId }) {
try {
let deposits = []
while (true) {
let result = await getDeposits({ currency, amount, fromBlock, netId })
if (isEmptyArray(result)) {
break
}
if (result.length < 900) {
deposits = deposits.concat(result)
break
}
const [lastEvent] = result.slice(-1)
result = result.filter((e) => e.blockNumber !== lastEvent.blockNumber)
fromBlock = Number(lastEvent.blockNumber)
deposits = deposits.concat(result)
}
if (!deposits) {
return {
lastSyncBlock: '',
events: []
}
}
const lastSyncBlock = await getMeta({ netId })
const data = deposits.map((e) => ({
timestamp: e.timestamp,
commitment: e.commitment,
leafIndex: Number(e.index),
blockNumber: Number(e.blockNumber),
transactionHash: e.transactionHash
}))
const [lastEvent] = data.slice(-1)
return {
events: data,
lastSyncBlock: lastEvent?.blockNumber >= lastSyncBlock ? lastEvent.blockNumber + 1 : lastSyncBlock
}
} catch {
return {
lastSyncBlock: '',
events: []
}
}
}
async function getMeta({ netId }) {
try {
const { data } = await client.query({
context: {
chainId: netId
},
query: gql(_META)
})
if (!data) {
return undefined
}
return data._meta.block.number
} catch {
return undefined
}
}
async function getRegisteredMeta() {
try {
const { data } = await registryClient.query({
context: {
chainId: 1
},
query: gql(_META)
})
if (!data) {
return undefined
}
return data._meta.block.number
} catch {
return undefined
}
}
async function getRegisters(fromBlock) {
const { data } = await registryClient.query({
context: {
chainId: 1
},
query: gql(GET_REGISTERED),
variables: { first, fromBlock }
})
if (!data) {
return []
}
return data.relayers
}
async function getDeposits({ currency, amount, fromBlock, netId }) {
const { data } = await client.query({
context: {
chainId: netId
},
query: gql(GET_DEPOSITS),
variables: { currency, amount: String(amount), first, fromBlock }
})
if (!data) {
return []
}
return data.deposits
}
async function getAllWithdrawals({ currency, amount, fromBlock, netId }) {
try {
let withdrawals = []
while (true) {
let result = await getWithdrawals({ currency, amount, fromBlock, netId })
if (isEmptyArray(result)) {
break
}
if (result.length < 900) {
withdrawals = withdrawals.concat(result)
break
}
const [lastEvent] = result.slice(-1)
result = result.filter((e) => e.blockNumber !== lastEvent.blockNumber)
fromBlock = Number(lastEvent.blockNumber)
withdrawals = withdrawals.concat(result)
}
if (!withdrawals) {
return {
lastSyncBlock: '',
events: []
}
}
const lastSyncBlock = await getMeta({ netId })
const data = withdrawals.map((e) => ({
to: e.to,
fee: e.fee,
timestamp: e.timestamp,
nullifierHash: e.nullifier,
blockNumber: Number(e.blockNumber),
transactionHash: e.transactionHash
}))
const [lastEvent] = data.slice(-1)
return {
events: data,
lastSyncBlock: lastEvent?.blockNumber >= lastSyncBlock ? lastEvent.blockNumber + 1 : lastSyncBlock
}
} catch {
return {
lastSyncBlock: '',
events: []
}
}
}
async function getWithdrawals({ currency, amount, fromBlock, netId }) {
const { data } = await client.query({
context: {
chainId: netId
},
query: gql(GET_WITHDRAWALS),
variables: { currency, amount: String(amount), fromBlock, first }
})
if (!data) {
return []
}
return data.withdrawals
}
async function getNoteAccounts({ address, netId }) {
try {
const { data } = await client.query({
context: {
chainId: netId
},
query: gql(GET_NOTE_ACCOUNTS),
variables: { address }
})
if (!data) {
return {
lastSyncBlock: '',
events: []
}
}
const lastSyncBlock = await getMeta({ netId })
return {
lastSyncBlock,
events: data.noteAccounts
}
} catch {
return {
lastSyncBlock: '',
events: []
}
}
}
async function getAllEncryptedNotes({ fromBlock, netId }) {
try {
let encryptedNotes = []
while (true) {
let result = await getEncryptedNotes({ fromBlock, netId })
if (isEmptyArray(result)) {
break
}
if (result.length < 900) {
encryptedNotes = encryptedNotes.concat(result)
break
}
const [lastEvent] = result.slice(-1)
result = result.filter((e) => e.blockNumber !== lastEvent.blockNumber)
fromBlock = Number(lastEvent.blockNumber)
encryptedNotes = encryptedNotes.concat(result)
if (isEmptyArray(result)) {
break
}
}
if (!encryptedNotes) {
return {
lastSyncBlock: '',
events: []
}
}
const lastSyncBlock = await getMeta({ netId })
const data = encryptedNotes.map((e) => ({
txHash: e.transactionHash,
encryptedNote: e.encryptedNote,
transactionHash: e.transactionHash,
blockNumber: Number(e.blockNumber)
}))
const [lastEvent] = data.slice(-1)
return {
events: data,
lastSyncBlock: lastEvent?.blockNumber >= lastSyncBlock ? lastEvent.blockNumber + 1 : lastSyncBlock
}
} catch {
return {
lastSyncBlock: '',
events: []
}
}
}
async function getEncryptedNotes({ fromBlock, netId }) {
const { data } = await client.query({
context: {
chainId: netId
},
query: gql(GET_ENCRYPTED_NOTES),
variables: { fromBlock, first }
})
if (!data) {
return []
}
return data.encryptedNotes
}
export default {
getDeposits,
getStatistic,
getAllDeposits,
getWithdrawals,
getNoteAccounts,
getAllRegisters,
getAllWithdrawals,
getAllEncryptedNotes
}