feat: Interpolate blockTime for older solana blocks

packages/solana/src/sdk/schema.ts

@@ -0,0 +1,188 @@
+import {
+  type as pick,
+  number,
+  string,
+  array,
+  boolean,
+  literal,
+  union,
+  optional,
+  nullable,
+  coerce,
+  unknown,
+  tuple,
+} from 'superstruct'
+
+const AddressTableLookupStruct = pick({
+  accountKey: string(),
+  writableIndexes: array(number()),
+  readonlyIndexes: array(number()),
+})
+
+const LoadedAddressesResult = pick({
+  writable: array(string()),
+  readonly: array(string()),
+})
+
+const TokenAmountResult = pick({
+  amount: string(),
+  uiAmount: nullable(number()),
+  decimals: number(),
+  uiAmountString: optional(string()),
+})
+
+const TokenBalanceResult = pick({
+  accountIndex: number(),
+  mint: string(),
+  owner: optional(string()),
+  uiTokenAmount: TokenAmountResult,
+})
+
+const TransactionErrorResult = nullable(union([pick({}), string()]))
+
+const RawInstructionResult = pick({
+  accounts: array(string()),
+  data: string(),
+  programId: string(),
+})
+
+const ParsedInstructionResult = pick({
+  parsed: unknown(),
+  program: string(),
+  programId: string(),
+})
+
+const InstructionResult = union([RawInstructionResult, ParsedInstructionResult])
+
+const UnknownInstructionResult = union([
+  pick({
+    parsed: unknown(),
+    program: string(),
+    programId: string(),
+  }),
+  pick({
+    accounts: array(string()),
+    data: string(),
+    programId: string(),
+  }),
+])
+
+const ParsedOrRawInstruction = coerce(
+  InstructionResult,
+  UnknownInstructionResult,
+  (value) => {
+    if ('accounts' in value) {
+      RawInstructionResult
+    } else {
+      ParsedInstructionResult
+    }
+  },
+)
+
+const ParsedConfirmedTransactionResult = pick({
+  signatures: array(string()),
+  message: pick({
+    accountKeys: array(
+      pick({
+        pubkey: string(),
+        signer: boolean(),
+        writable: boolean(),
+        source: optional(
+          union([literal('transaction'), literal('lookupTable')]),
+        ),
+      }),
+    ),
+    instructions: array(ParsedOrRawInstruction),
+    recentBlockhash: string(),
+    addressTableLookups: optional(nullable(array(AddressTableLookupStruct))),
+  }),
+})
+
+const TransactionVersionStruct = union([literal(0), literal('legacy')])
+
+const ParsedConfirmedTransactionMetaResult = pick({
+  err: TransactionErrorResult,
+  fee: number(),
+  innerInstructions: optional(
+    nullable(
+      array(
+        pick({
+          index: number(),
+          instructions: array(ParsedOrRawInstruction),
+        }),
+      ),
+    ),
+  ),
+  preBalances: array(number()),
+  postBalances: array(number()),
+  logMessages: optional(nullable(array(string()))),
+  preTokenBalances: optional(nullable(array(TokenBalanceResult))),
+  postTokenBalances: optional(nullable(array(TokenBalanceResult))),
+  loadedAddresses: optional(LoadedAddressesResult),
+  computeUnitsConsumed: optional(number()),
+})
+
+const VoteAccountInfoResult = pick({
+  votePubkey: string(),
+  nodePubkey: string(),
+  activatedStake: number(),
+  epochVoteAccount: boolean(),
+  epochCredits: array(tuple([number(), number(), number()])),
+  commission: number(),
+  lastVote: number(),
+  rootSlot: nullable(number()),
+})
+
+const SupplyContext = pick({
+  apiVersion: string(),
+  slot: number(),
+})
+
+const SupplyValue = pick({
+  total: number(),
+  circulating: number(),
+  nonCirculating: number(),
+  nonCirculatingAccounts: array(string()),
+})
+
+/**
+ * Expected JSON RPC response for the "getSupply" message
+ */
+export const GetSupplyRpcResult = pick({
+  context: SupplyContext,
+  value: SupplyValue,
+})
+
+/**
+ * Expected JSON RPC response for the "getSignaturesForAddress" message
+ */
+export const GetSignaturesForAddressRpcResult = array(
+  pick({
+    signature: string(),
+    slot: number(),
+    err: TransactionErrorResult,
+    memo: nullable(string()),
+    blockTime: optional(nullable(number())),
+  }),
+)
+
+/**
+ * Expected JSON RPC response for the "getTransaction" message
+ */
+export const GetParsedTransactionRpcResult = nullable(
+  pick({
+    slot: number(),
+    transaction: ParsedConfirmedTransactionResult,
+    meta: nullable(ParsedConfirmedTransactionMetaResult),
+    blockTime: optional(nullable(number())),
+    version: optional(TransactionVersionStruct),
+  }),
+)
+
+/**
+ * Expected JSON RPC response for the "getVoteAccounts" message
+ */
+export const GetVoteAccounts = pick({
+  current: array(VoteAccountInfoResult),
+  delinquent: array(VoteAccountInfoResult),
+})

packages/solana/src/services/fetcher/src/accountTransactionHistoryFetcher.ts

@@ -1,5 +1,4 @@
 import { Duration } from 'luxon'
-import { ConfirmedSignatureInfo } from '@solana/web3.js'
 import { Utils } from '@aleph-indexer/core'
 import {
   BaseFetcherPaginationCursors,
@@ -13,6 +12,7 @@ import { SolanaAccountTransactionHistoryStorage } from './dal/accountTransaction
 import {
   SolanaAccountTransactionHistoryPaginationCursor,
   SolanaSignature,
+  SolanaSignatureInfo,
 } from './types.js'
 import {
   SolanaErrorFetching,
@@ -247,7 +247,7 @@ export class SolanaAccountTransactionHistoryFetcher extends BaseHistoryFetcher<S
   }
 
   protected async processSignatures(
-    signatures: ConfirmedSignatureInfo[],
+    signatures: SolanaSignatureInfo[],
     goingForward: boolean,
     runOffset: number,
     sigOffset: number,
@@ -267,15 +267,9 @@ export class SolanaAccountTransactionHistoryFetcher extends BaseHistoryFetcher<S
     const sigs = signatures.map((signature, index) => {
       const offset = runOffset * 1000000 + (999999 - (index + sigOffset))
 
-      const sig = signature as any
-      sig.id = sig.signature
-
-      delete sig.memo
-      delete sig.confirmationStatus
-
+      const sig = signature as SolanaSignature
       sig.accountSlotIndex = sig.accountSlotIndex || {}
       sig.accountSlotIndex[this.account] = offset
-
       sig.accounts = Object.keys(sig.accountSlotIndex)
 
       return sig

packages/solana/src/services/fetcher/src/dal/accountTransactionHistory.ts

@@ -29,7 +29,7 @@ const accountKey = {
 }
 
 const timestampKey = {
-  get: (e: SolanaSignature) => (e.blockTime || 0) * 1000,
+  get: (e: SolanaSignature) => e.timestamp,
   length: EntityStorage.TimestampLength,
 }
 

packages/solana/src/services/fetcher/src/types.ts

@@ -15,14 +15,16 @@ export type SolanaAccountTransactionHistoryPaginationCursor = {
   timestamp?: number
 }
 
-export type SolanaSignatureInfo = ConfirmedSignatureInfo
-
-export type SolanaSignature = Omit<
+export type SolanaSignatureInfo = Omit<
   ConfirmedSignatureInfo,
   'memo' | 'confirmationStatus'
 > & {
   id: string
+  signature: string
   timestamp: number
+}
+
+export type SolanaSignature = SolanaSignatureInfo & {
   accountSlotIndex: Record<string, number>
   accounts: string[]
 }

packages/solana/src/services/indexer/src/transactionFetcher.ts

@@ -59,7 +59,7 @@ export class SolanaIndexerTransactionFetcher extends BaseIndexerEntityFetcher<So
             continue
           }
 
-          const timestamp = (tx.blockTime || 0) * 1000
+          const timestamp = tx.timestamp
 
           let valid = timestamp >= startDate && timestamp <= endDate
 

packages/solana/src/services/parser/src/event/eventParser.ts

@@ -26,9 +26,7 @@ export abstract class EventParser<
         : ''
     }:${instruction.index.toString().padStart(2, '0')}`
 
-    const timestamp = parentTransaction.blockTime
-      ? parentTransaction.blockTime * 1000
-      : parentTransaction.slot
+    const timestamp = parentTransaction.timestamp
 
     return {
       ...parsed.info,

packages/solana/src/types.ts

@@ -158,7 +158,11 @@ export type SolanaRawTransactionOld = ConfirmedSignatureInfo &
 /**
  * Expected JSON RPC response for the "getTransaction" message
  */
-export type SolanaRawTransaction = RawEntity & RawParsedTransactionWithMeta
+export type SolanaRawTransaction = RawEntity &
+  RawParsedTransactionWithMeta & {
+    signature: string
+    timestamp: number
+  }
 
 export type RawAccountInfo = AccountInfo<Buffer>
 
@@ -223,7 +227,7 @@ export type SolanaParsedTransaction = Omit<
   parsed: AlephParsedInnerTransaction
   index: number
   signature: string
-  blocktime: number
+  blockTime?: number
   slot: number
 }
 

packages/solana/src/utils/api.ts

@@ -230,11 +230,13 @@ export const TransactionError = new GraphQLObjectType({
 export const TransactionItem = new GraphQLObjectType({
   name: 'TransactionItem',
   fields: {
+    id: { type: new GraphQLNonNull(GraphQLString) },
     signature: { type: new GraphQLNonNull(GraphQLString) },
     slot: { type: new GraphQLNonNull(GraphQLInt) },
     err: { type: TransactionError },
     memo: { type: GraphQLString },
     blockTime: { type: GraphQLLong },
+    timestamp: { type: GraphQLLong },
     parsed: { type: ParsedTransactionType },
     meta: { type: ParsedConfirmedTransactionMeta },
   },