@subsquid/solana-stream 0.1.4 → 0.2.0-2-0.3887d2

package/src/archive/source.ts

@@ -1,105 +0,0 @@
-import {BlockHeader} from '@subsquid/solana-normalization'
-import {Base58Bytes} from '@subsquid/solana-rpc-data'
-import {assertNotNull} from '@subsquid/util-internal'
-import {ArchiveClient} from '@subsquid/util-internal-archive-client'
-import {archiveIngest} from '@subsquid/util-internal-ingest-tools'
-import {getRequestAt, mapRangeRequestList, RangeRequestList} from '@subsquid/util-internal-range'
-import {array, cast} from '@subsquid/util-internal-validation'
-import assert from 'assert'
-import {PartialBlock} from '../data/partial'
-import {DataRequest} from '../data/request'
-import {getDataSchema} from './schema'
-
-
-export class SolanaArchive {
-    constructor(private client: ArchiveClient) {}
-
-    getFinalizedHeight(): Promise<number> {
-        return this.client.getHeight()
-    }
-
-    async getBlockHash(height: number): Promise<Base58Bytes | undefined> {
-        let blocks = await this.client.query({
-            type: 'solana',
-            fromBlock: height,
-            toBlock: height,
-            includeAllBlocks: true
-        })
-        assert(blocks.length == 1)
-        return blocks[0].header.hash
-    }
-
-    async getBlockHeader(height: number): Promise<BlockHeader> {
-        let blocks = await this.client.query({
-            type: 'solana',
-            fromBlock: height,
-            toBlock: height,
-            includeAllBlocks: true,
-            fields: {
-                block: {
-                    slot: true,
-                    parentSlot: true,
-                    parentHash: true,
-                    timestamp: true
-                }
-            }
-        })
-        assert(blocks.length == 1)
-        let {number, ...rest} = blocks[0].header
-        return {
-            height: number,
-            ...rest
-        } as BlockHeader
-    }
-
-    async *getBlockStream(requests: RangeRequestList<DataRequest>, stopOnHead?: boolean | undefined): AsyncIterable<PartialBlock[]> {
-        let archiveRequests = mapRangeRequestList(requests, req => {
-            let {fields, includeAllBlocks, ...items} = req
-            let archiveItems: any = {}
-            let key: keyof typeof items
-            for (key in items) {
-                archiveItems[key] = items[key]?.map(it => ({...it.where, ...it.include}))
-            }
-            return {
-                type: 'solana',
-                fields: {
-                    block: {parentHash: true, ...fields?.block},
-                    transaction: fields?.transaction,
-                    instruction: fields?.instruction,
-                    log: {instructionAddress: true, ...fields?.log},
-                    balance: fields?.balance,
-                    tokenBalance: fields?.tokenBalance,
-                    reward: fields?.reward
-                },
-                includeAllBlocks,
-                ...archiveItems
-            }
-        })
-
-        for await (let batch of archiveIngest({
-            client: this.client,
-            requests: archiveRequests,
-            stopOnHead
-        })) {
-            let req = getRequestAt(requests, batch.blocks[0].header.number)
-
-            let blocks = cast(
-                array(getDataSchema(assertNotNull(req?.fields))),
-                batch.blocks
-            ).map(b => {
-                let {header: {number, ...hdr}, ...items} = b
-                return {
-                    header: {height: number, ...hdr},
-                    transactions: items.transactions || [],
-                    instructions: items.instructions || [],
-                    logs: items.logs || [],
-                    balances: items.balances || [],
-                    tokenBalances: items.tokenBalances || [],
-                    rewards: items.rewards || []
-                }
-            })
-
-            yield blocks
-        }
-    }
-}

package/src/data/fields.ts

@@ -1,50 +0,0 @@
-import {DEFAULT_FIELDS, FieldSelection} from './model'
-import {Selector} from './type-util'
-
-
-/**
- * Get effective set of selected fields.
- */
-export function getFields(fields: FieldSelection | undefined): FieldSelection {
-    return {
-        block: merge(DEFAULT_FIELDS.block, fields?.block),
-        transaction: merge(DEFAULT_FIELDS.transaction, fields?.transaction),
-        instruction: merge(DEFAULT_FIELDS.instruction, fields?.instruction),
-        log: merge(DEFAULT_FIELDS.log, fields?.log),
-        balance: merge(DEFAULT_FIELDS.balance, fields?.balance),
-        tokenBalance: merge(DEFAULT_FIELDS.tokenBalance, fields?.tokenBalance),
-        reward: merge(DEFAULT_FIELDS.reward, fields?.reward)
-    }
-}
-
-
-function merge<Keys extends string>(def: Selector<Keys>, requested: Selector<Keys> = {}): Selector<Keys> {
-    let fields: Selector<Keys> = {}
-
-    for (let key in def) {
-        if (requested[key] !== false) {
-            fields[key] = def[key]
-        }
-    }
-
-    for (let key in requested) {
-        if (requested[key]) {
-            fields[key] = true
-        }
-    }
-
-    return fields
-}
-
-
-export function project<T>(fields: Selector<keyof T> | undefined, obj: T): Partial<T> {
-    if (fields == null) return {}
-    let result: Partial<T> = {}
-    let key: keyof T
-    for (key in obj) {
-        if (fields[key]) {
-            result[key] = obj[key]
-        }
-    }
-    return result
-}

package/src/data/model.ts

@@ -1,154 +0,0 @@
-import type * as data from '@subsquid/solana-normalization'
-import type {
-    BalanceRequiredFields,
-    BlockRequiredFields,
-    InstructionRequiredFields,
-    LogRequiredFields,
-    RewardRequiredFields,
-    TokenBalanceRequiredFields,
-    TransactionRequiredFields
-} from './partial'
-import type {GetFields, Select, Selector, Simplify} from './type-util'
-
-
-/**
- * Hex encoded binary string
- */
-export type Bytes = string
-
-
-/**
- * Base58 encoded binary string
- */
-export type Base58Bytes = string
-
-
-export interface FieldSelection {
-    block?: Selector<Exclude<keyof data.BlockHeader, BlockRequiredFields>>
-    transaction?: Selector<Exclude<keyof data.Transaction, TransactionRequiredFields>>
-    instruction?: Selector<Exclude<keyof data.Instruction, InstructionRequiredFields>>
-    log?: Selector<Exclude<keyof data.LogMessage, LogRequiredFields>>
-    balance?: Selector<Exclude<keyof data.Balance, BalanceRequiredFields>>
-    tokenBalance?: Selector<Exclude<keyof data.TokenBalance, TokenBalanceRequiredFields>>
-    reward?: Selector<Exclude<keyof data.Reward, RewardRequiredFields>>
-}
-
-
-export const DEFAULT_FIELDS = {
-    block: {
-        slot: true,
-        parentSlot: true,
-        timestamp: true
-    },
-    transaction: {
-        signatures: true,
-        err: true
-    },
-    instruction: {
-        programId: true,
-        accounts: true,
-        data: true,
-        isCommitted: true
-    },
-    log: {
-        programId: true,
-        kind: true,
-        message: true
-    },
-    balance: {
-        pre: true,
-        post: true
-    },
-    tokenBalance: {
-        preMint: true,
-        preDecimals: true,
-        preOwner: true,
-        preAmount: true,
-        postMint: true,
-        postDecimals: true,
-        postOwner: true,
-        postAmount: true
-    },
-    reward: {
-        lamports: true,
-        rewardType: true
-    }
-} as const
-
-
-type Item<
-    Data,
-    RequiredFields extends keyof Data,
-    F extends FieldSelection,
-    K extends keyof FieldSelection
-> = Simplify<
-    Pick<Data, RequiredFields> &
-    Select<Data, GetFields<FieldSelection, typeof DEFAULT_FIELDS, F, K>>
->
-
-
-export type BlockHeader<F extends FieldSelection = {}> = Item<
-    data.BlockHeader,
-    BlockRequiredFields,
-    F,
-    'block'
->
-
-
-export type Transaction<F extends FieldSelection = {}> = Item<
-    data.Transaction,
-    TransactionRequiredFields,
-    F,
-    'transaction'
->
-
-
-export type Instruction<F extends FieldSelection = {}> = Item<
-    data.Instruction,
-    InstructionRequiredFields,
-    F,
-    'instruction'
->
-
-
-export type LogMessage<F extends FieldSelection = {}> = Item<
-    data.LogMessage,
-    LogRequiredFields,
-    F,
-    'log'
->
-
-
-export type Balance<F extends FieldSelection = {}> = Item<
-    data.Balance,
-    BalanceRequiredFields,
-    F,
-    'balance'
->
-
-
-export type TokenBalance<F extends FieldSelection = {}> = Item<
-    data.TokenBalance,
-    TokenBalanceRequiredFields,
-    F,
-    'tokenBalance'
->
-
-
-export type Reward<F extends FieldSelection = {}> = Item<
-    data.Reward,
-    RewardRequiredFields,
-    F,
-    'reward'
->
-
-
-export interface Block<F extends FieldSelection = {}> {
-    header: BlockHeader<F>
-    transactions: Transaction<F>[]
-    instructions: Instruction<F>[]
-    logs: LogMessage<F>[]
-    balances: Balance<F>[]
-    tokenBalances: TokenBalance<F>[]
-    rewards: Reward<F>[]
-}

package/src/data/partial.ts

@@ -1,31 +0,0 @@
-import type * as data from '@subsquid/solana-normalization'
-import type {MakePartial} from './type-util'
-
-
-export type BlockRequiredFields = 'height' | 'hash' | 'parentHash'
-export type TransactionRequiredFields = 'transactionIndex'
-export type InstructionRequiredFields = 'transactionIndex' | 'instructionAddress'
-export type LogRequiredFields = 'transactionIndex' | 'logIndex' | 'instructionAddress'
-export type BalanceRequiredFields = 'transactionIndex' | 'account'
-export type TokenBalanceRequiredFields = 'transactionIndex' | 'account'
-export type RewardRequiredFields = 'pubkey'
-
-
-export type PartialBlockHeader = MakePartial<data.BlockHeader, BlockRequiredFields>
-export type PartialTransaction = MakePartial<data.Transaction, TransactionRequiredFields>
-export type PartialInstruction = MakePartial<data.Instruction, InstructionRequiredFields>
-export type PartialLogMessage = MakePartial<data.LogMessage, LogRequiredFields>
-export type PartialBalance = MakePartial<data.Balance, BalanceRequiredFields>
-export type PartialTokenBalance = MakePartial<data.PrePostTokenBalance, TokenBalanceRequiredFields>
-export type PartialReward = MakePartial<data.Reward, RewardRequiredFields>
-
-
-export interface PartialBlock {
-    header: PartialBlockHeader
-    transactions: PartialTransaction[]
-    instructions: PartialInstruction[]
-    logs: PartialLogMessage[]
-    balances: PartialBalance[]
-    tokenBalances: PartialTokenBalance[]
-    rewards: PartialReward[]
-}

package/src/data/request.ts

@@ -1,140 +0,0 @@
-import {Base58Bytes} from '@subsquid/solana-rpc'
-import {LogMessage} from '@subsquid/solana-normalization'
-import {FieldSelection} from './model'
-
-
-export interface DataRequest {
-    fields?: FieldSelection
-    includeAllBlocks?: boolean
-    transactions?: TransactionRequest[]
-    instructions?: InstructionRequest[]
-    logs?: LogRequest[]
-    balances?: BalanceRequest[]
-    tokenBalances?: TokenBalanceRequest[]
-    rewards?: RewardRequest[]
-}
-
-
-export interface TransactionRequest {
-    where?: TransactionRequestWhere
-    include?: TransactionRequestRelations
-}
-
-
-export interface TransactionRequestWhere {
-    feePayer?: Base58Bytes[]
-}
-
-
-export interface TransactionRequestRelations {
-    instructions?: boolean
-    logs?: boolean
-}
-
-/**
- * Hex encoded prefix of instruction data
- */
-export type Discriminator = string
-
-
-export interface InstructionRequest {
-    where?: InstructionRequestWhere
-    include?: InstructionRequestRelations
-}
-
-
-export interface InstructionRequestWhere {
-    programId?: Base58Bytes[]
-    d1?: Discriminator[]
-    d2?: Discriminator[]
-    d3?: Discriminator[]
-    d4?: Discriminator[]
-    d8?: Discriminator[]
-    a0?: Base58Bytes[]
-    a1?: Base58Bytes[]
-    a2?: Base58Bytes[]
-    a3?: Base58Bytes[]
-    a4?: Base58Bytes[]
-    a5?: Base58Bytes[]
-    a6?: Base58Bytes[]
-    a7?: Base58Bytes[]
-    a8?: Base58Bytes[]
-    a9?: Base58Bytes[]
-    isCommitted?: boolean
-}
-
-
-export interface InstructionRequestRelations {
-    transaction?: boolean
-    transactionBalances?: boolean
-    transactionTokenBalances?: boolean
-    transactionInstructions?: boolean
-    logs?: boolean
-    innerInstructions?: boolean
-}
-
-
-export interface LogRequest {
-    where?: LogRequestWhere
-    include?: LogRequestRelations
-}
-
-
-export interface LogRequestWhere {
-    programId?: Base58Bytes[]
-    kind?: LogMessage['kind'][]
-}
-
-
-export interface LogRequestRelations {
-    transaction?: boolean
-    instruction?: boolean
-}
-
-
-export interface BalanceRequest {
-    where?: BalanceRequestWhere
-    include?: BalanceRequestRelations
-}
-
-
-export interface BalanceRequestWhere {
-    account?: Base58Bytes[]
-}
-
-
-export interface BalanceRequestRelations {
-    transaction?: boolean
-    transactionInstructions?: boolean
-}
-
-
-export interface TokenBalanceRequest {
-    where?: TokenBalanceRequestWhere
-    include?: TokenBalanceRequestRelations
-}
-
-
-export interface TokenBalanceRequestWhere {
-    account?: Base58Bytes[]
-    preProgramId?: Base58Bytes[]
-    postProgramId?: Base58Bytes[]
-    preMint?: Base58Bytes[]
-    postMint?: Base58Bytes[]
-    preOwner?: Base58Bytes[]
-    postOwner?: Base58Bytes[]
-}
-
-
-export interface TokenBalanceRequestRelations {
-    transaction?: boolean
-    transactionInstructions?: boolean
-}
-
-
-export interface RewardRequest {
-    where?: {
-        pubkey?: Base58Bytes[]
-    }
-    include?: undefined
-}

package/src/data/type-util.ts

@@ -1,42 +0,0 @@
-export type Simplify<T> = {
-    [K in keyof T]: T[K]
-} & {}
-
-
-export type ExcludeUndefined<T> = {
-    [K in keyof T as undefined extends T[K] ? never : K]: T[K]
-} & {}
-
-
-export type GetFields<
-    FieldSelectionType,
-    Defaults extends FieldSelectionType,
-    Selection extends FieldSelectionType,
-    K extends keyof FieldSelectionType
-> = TrueFields<MergeDefault<Selection[K], Defaults[K]>>
-
-
-type MergeDefault<T, D> = Simplify<
-    undefined extends T ? D : Omit<D, keyof ExcludeUndefined<T>> & ExcludeUndefined<T>
->
-
-
-type TrueFields<F> = keyof {
-    [K in keyof F as true extends F[K] ? K : never]: true
-}
-
-
-export type Select<T, Fields> = T extends any ? Simplify<Pick<T, Extract<keyof T, Fields>>> : never
-
-
-export type Selector<Fields extends string | number | symbol> = {
-    [P in Fields]?: boolean
-}
-
-
-export type MakePartial<T, Required extends keyof T> = Simplify<
-    Pick<T, Required> &
-    {
-        [K in keyof T as K extends Required ? never : K]+?: T[K]
-    }
->

package/src/rpc/client.ts

@@ -1,26 +0,0 @@
-import {RpcClient, RpcClientOptions} from '@subsquid/rpc-client'
-
-
-export interface SolanaRpcClientOptions extends RpcClientOptions {
-    /**
-     * Retry on connection error.
-     *
-     * By default, retries indefinitely.
-     */
-    retryAttempts?: number
-    /**
-     * Unsafe integer check must be always enabled
-     */
-    fixUnsafeIntegers?: true
-}
-
-
-export class SolanaRpcClient extends RpcClient {
-    constructor(options: SolanaRpcClientOptions) {
-        super({
-            retryAttempts: Number.MAX_SAFE_INTEGER,
-            ...options,
-            fixUnsafeIntegers: true
-        })
-    }
-}