feat: solana balances

packages/aleph-holders/package.json

@@ -19,6 +19,7 @@
     "@aleph-indexer/bsc": "^1.1.11",
     "@aleph-indexer/core": "^1.1.10",
     "@aleph-indexer/ethereum": "^1.1.11",
+    "@aleph-indexer/solana": "^1.1.11",
     "@aleph-indexer/framework": "^1.1.11"
   }
 }

packages/aleph-holders/run.ts

@@ -18,7 +18,7 @@ async function main() {
 
   const projectId = config.INDEXER_NAMESPACE || 'aleph-holders'
   const supportedBlockchains = (
-    config.INDEXER_BLOCKCHAINS || 'ethereum,bsc'
+    config.INDEXER_BLOCKCHAINS || 'ethereum,bsc,solana'
   ).split(',') as Blockchain[]
   const dataPath = config.INDEXER_DATA_PATH || undefined // 'data'
   const transport =

packages/aleph-holders/src/api/args.ts

@@ -7,7 +7,7 @@ import {
 } from 'graphql'
 import { GraphQLBlockchain } from '@aleph-indexer/framework'
 
-export const ERC20TransferEventQueryArgs = {
+export const TransferEventQueryArgs = {
   blockchain: { type: new GraphQLNonNull(GraphQLBlockchain) },
   account: { type: GraphQLString },
   startDate: { type: GraphQLFloat },
@@ -19,7 +19,7 @@ export const ERC20TransferEventQueryArgs = {
   reverse: { type: GraphQLBoolean },
 }
 
-export const ERC20BalanceQueryArgs = {
+export const BalanceQueryArgs = {
   blockchain: { type: new GraphQLNonNull(GraphQLBlockchain) },
   account: { type: GraphQLString },
   limit: { type: GraphQLInt },

packages/aleph-holders/src/api/resolvers.ts

@@ -2,20 +2,23 @@ import MainDomain from '../domain/main.js'
 import {
   Balance,
   BalanceQueryArgs,
-  ERC20TransferEvent,
-  ERC20TransferEventQueryArgs,
+  Snapshot,
+  TransferEvent,
+  TransferEventQueryArgs,
 } from '../types.js'
 
 export class APIResolver {
   constructor(protected domain: MainDomain) {}
 
-  async getEvents(
-    args: ERC20TransferEventQueryArgs,
-  ): Promise<ERC20TransferEvent[]> {
+  async getEvents(args: TransferEventQueryArgs): Promise<TransferEvent[]> {
     return this.domain.getEvents(args)
   }
 
   async getBalances(args: BalanceQueryArgs): Promise<Balance[]> {
     return this.domain.getBalances(args)
   }
+
+  async getSnapshot(timestamp?: number): Promise<Snapshot> {
+    return this.domain.getSnapshot(timestamp)
+  }
 }

packages/aleph-holders/src/api/schema.ts

@@ -1,10 +1,11 @@
-import { GraphQLObjectType } from 'graphql'
+import { GraphQLInt, GraphQLObjectType } from 'graphql'
 import { IndexerAPISchema } from '@aleph-indexer/framework'
 import * as Types from './types.js'
 import * as Args from './args.js'
 import { APIResolver } from './resolvers.js'
 import MainDomain from '../domain/main.js'
-import { BalanceQueryArgs, ERC20TransferEventQueryArgs } from '../types.js'
+import { BalanceQueryArgs, TransferEventQueryArgs } from '../types.js'
+import { GraphQLLong } from '@aleph-indexer/core'
 
 export default class APISchema extends IndexerAPISchema {
   constructor(
@@ -18,17 +19,25 @@ export default class APISchema extends IndexerAPISchema {
         name: 'Query',
         fields: {
           events: {
-            type: Types.ERC20TransferEventList,
-            args: Args.ERC20TransferEventQueryArgs,
+            type: Types.TransferEventList,
+            args: Args.TransferEventQueryArgs,
             resolve: (_, args) =>
-              this.resolver.getEvents(args as ERC20TransferEventQueryArgs),
+              this.resolver.getEvents(args as TransferEventQueryArgs),
           },
           balances: {
-            type: Types.ERC20BalanceList,
-            args: Args.ERC20BalanceQueryArgs,
+            type: Types.BalanceList,
+            args: Args.BalanceQueryArgs,
             resolve: (_, args) =>
               this.resolver.getBalances(args as BalanceQueryArgs),
           },
+          snapshot: {
+            type: Types.Snapshot,
+            args: {
+              timestamp: { type: GraphQLLong },
+            },
+            resolve: (_, args) =>
+              this.resolver.getSnapshot(args.timestamp),
+          },
         },
       }),
     })

packages/aleph-holders/src/api/types.ts

@@ -16,8 +16,8 @@ const commonFields = {
   transaction: { type: new GraphQLNonNull(GraphQLString) },
 }
 
-export const ERC20TransferEvent = new GraphQLObjectType({
-  name: 'ERC20TransferEvent',
+export const TransferEvent = new GraphQLObjectType({
+  name: 'TransferEvent',
   fields: {
     ...commonFields,
     from: { type: new GraphQLNonNull(GraphQLString) },
@@ -27,17 +27,37 @@ export const ERC20TransferEvent = new GraphQLObjectType({
   },
 })
 
-export const ERC20TransferEventList = new GraphQLList(ERC20TransferEvent)
+export const TransferEventList = new GraphQLList(TransferEvent)
 
-export const ERC20Balance = new GraphQLObjectType({
-  name: 'ERC20Balance',
+export const Balance = new GraphQLObjectType({
+  name: 'Balance',
   fields: {
     account: { type: new GraphQLNonNull(GraphQLString) },
     balance: { type: new GraphQLNonNull(GraphQLBigNumber) },
     balanceNum: { type: GraphQLFloat },
   },
 })
 
-export const ERC20BalanceList = new GraphQLList(ERC20Balance)
+export const BalanceList = new GraphQLList(Balance)
 
-export const types = [ERC20TransferEvent, ERC20Balance]
+export const SolanaBalance = new GraphQLObjectType({
+  name: 'SolanaBalance',
+  fields: {
+    account: { type: new GraphQLNonNull(GraphQLString) },
+    owner: { type: new GraphQLNonNull(GraphQLString) },
+    balance: { type: new GraphQLNonNull(GraphQLBigNumber) },
+    balanceNum: { type: GraphQLFloat },
+  },
+})
+
+export const SolanaBalanceList = new GraphQLList(SolanaBalance)
+
+export const Snapshot = new GraphQLObjectType({
+  name: 'Snapshot',
+  fields: {
+    timestamp: { type: new GraphQLNonNull(GraphQLString) },
+    balances: { type: new GraphQLNonNull(SolanaBalanceList) },
+  },
+})
+
+export const types = [TransferEvent, Balance, Snapshot]

packages/aleph-holders/src/dal/balance.ts

@@ -15,7 +15,7 @@ export enum BalanceDALIndex {
 
 const accountKey = {
   get: (e: Balance) => e.account,
-  length: EntityStorage.EthereumAddressLength,
+  length: EntityStorage.AddressLength,
 }
 
 const blockchainKey = {
@@ -49,7 +49,7 @@ const mapValueFn = async (value: any) => {
 
 export function createBalanceDAL(path: string): BalanceStorage {
   return new EntityStorage<Balance>({
-    name: 'erc20_balance',
+    name: 'balance',
     path,
     key: [blockchainKey, accountKey],
     indexes: [

packages/aleph-holders/src/dal/snapshot.ts

@@ -0,0 +1,17 @@
+import { EntityStorage } from '@aleph-indexer/core'
+import { Snapshot } from '../types.js'
+
+export type SnapshotStorage = EntityStorage<Snapshot>
+
+const timestampKey = {
+  get: (e: Snapshot) => e.timestamp,
+  length: EntityStorage.TimestampLength,
+}
+
+export function createSnapshotDAL(path: string): SnapshotStorage {
+  return new EntityStorage<Snapshot>({
+    name: 'snapshot',
+    path,
+    key: [timestampKey],
+  })
+}

packages/aleph-holders/src/dal/erc20TransferEvent.ts → packages/aleph-holders/src/dal/transfer.ts

@@ -1,43 +1,44 @@
 import { EntityStorage } from '@aleph-indexer/core'
-import { ERC20TransferEvent } from '../types.js'
+import { TransferEvent } from '../types.js'
 import {
   blockchainDecimals,
   uint256ToBigNumber,
   uint256ToNumber,
 } from '../utils/index.js'
 
-export type ERC20TransferEventStorage = EntityStorage<ERC20TransferEvent>
+export type TransferEventStorage = EntityStorage<TransferEvent>
 
-export enum ERC20TransferEventDALIndex {
+export enum TransferEventDALIndex {
   BlockchainTimestamp = 'blockchain_timestamp',
   BlockchainHeight = 'blockchain_height',
   BlockchainAccountTimestamp = 'blockchain_account_timestamp',
   BlockchainAccountHeight = 'blockchain_account_height',
 }
 
 const idKey = {
-  get: (e: ERC20TransferEvent) => e.id,
+  get: (e: TransferEvent) => e.id,
   length: EntityStorage.VariableLength,
 }
 
 const accountKey = {
-  get: (e: ERC20TransferEvent) => [e.from, e.to],
-  length: EntityStorage.EthereumAddressLength,
+  get: (e: TransferEvent) => [e.from, e.to],
+  length: EntityStorage.AddressLength,
 }
 
 const blockchainKey = {
-  get: (e: ERC20TransferEvent) => e.blockchain,
+  get: (e: TransferEvent) => e.blockchain,
   length: EntityStorage.VariableLength,
 }
 
 const timestampKey = {
-  get: (e: ERC20TransferEvent) => e.timestamp,
+  get: (e: TransferEvent) => e.timestamp,
   length: EntityStorage.TimestampLength,
 }
 
 const heightKey = {
-  get: (e: ERC20TransferEvent) => e.height,
+  get: (e: TransferEvent) => e.height,
   // @note: up to 10**9 [9 digits] enough for 300 years in ethereum
+  // on solana 14 years aprox, block gen each 400ms
   length: 8,
 }
 
@@ -60,28 +61,26 @@ const mapValueFn = async (value: any) => {
   return value
 }
 
-export function createERC20TransferEventDAL(
-  path: string,
-): ERC20TransferEventStorage {
-  return new EntityStorage<ERC20TransferEvent>({
-    name: 'erc20_transfer_event',
+export function createTransferEventDAL(path: string): TransferEventStorage {
+  return new EntityStorage<TransferEvent>({
+    name: 'transfer_event',
     path,
     key: [idKey],
     indexes: [
       {
-        name: ERC20TransferEventDALIndex.BlockchainTimestamp,
+        name: TransferEventDALIndex.BlockchainTimestamp,
         key: [blockchainKey, timestampKey],
       },
       {
-        name: ERC20TransferEventDALIndex.BlockchainHeight,
+        name: TransferEventDALIndex.BlockchainHeight,
         key: [blockchainKey, heightKey],
       },
       {
-        name: ERC20TransferEventDALIndex.BlockchainAccountTimestamp,
+        name: TransferEventDALIndex.BlockchainAccountTimestamp,
         key: [blockchainKey, accountKey, timestampKey],
       },
       {
-        name: ERC20TransferEventDALIndex.BlockchainAccountHeight,
+        name: TransferEventDALIndex.BlockchainAccountHeight,
         key: [blockchainKey, accountKey, heightKey],
       },
     ],

packages/aleph-holders/src/domain/parser.ts → packages/aleph-holders/src/domain/ethereumParser.ts

@@ -1,17 +1,17 @@
 import { BlockchainId } from '@aleph-indexer/framework'
 import { EthereumParsedLog } from '@aleph-indexer/ethereum'
-import { AlephEvent, Balance, ERC20TransferEvent } from '../types.js'
+import { AlephEvent, Balance, TransferEvent } from '../types.js'
 import {
   bigNumberToString,
   uint256ToBigNumber,
   uint256ToString,
 } from '../utils/index.js'
 
-export class EventParser {
+export class EthereumEventParser {
   parseERC20TransferEvent(
     blockchain: BlockchainId,
     entity: EthereumParsedLog,
-  ): ERC20TransferEvent {
+  ): TransferEvent {
     const parsedEvent = this.parseCommonScheme(blockchain, entity)
 
     const [rawFrom, rawTo, rawValue] = entity.parsed?.args || []