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

package/src/source.ts

@@ -1,392 +1,121 @@
-import {HttpAgent, HttpClient} from '@subsquid/http-client'
-import {BlockInfo} from '@subsquid/solana-rpc'
-import {Base58Bytes} from '@subsquid/solana-rpc-data'
-import {addErrorContext, def, last} from '@subsquid/util-internal'
-import {ArchiveClient} from '@subsquid/util-internal-archive-client'
-import {getOrGenerateSquidId} from '@subsquid/util-internal-processor-tools'
+import {applyRangeBound, mergeRangeRequests, Range, RangeRequest} from '@subsquid/util-internal-range'
+import {PortalClient, PortalStreamData} from '@subsquid/portal-client'
+import {cast} from '@subsquid/util-internal-validation'
 import {
-    applyRangeBound,
-    FiniteRange,
-    getSize,
-    mergeRangeRequests,
-    Range,
-    RangeRequest,
-    RangeRequestList
-} from '@subsquid/util-internal-range'
-import assert from 'assert'
-import {SolanaArchive} from './archive/source'
-import {getFields} from './data/fields'
-import {Block, BlockHeader, FieldSelection} from './data/model'
-import {PartialBlock} from './data/partial'
-import {
-    BalanceRequest,
+    BlockData,
     DataRequest,
-    InstructionRequest,
-    LogRequest,
-    RewardRequest,
-    TokenBalanceRequest,
-    TransactionRequest
-} from './data/request'
-import {SolanaRpcClient} from './rpc/client'
-import {RpcDataSource} from './rpc/source'
-
-
-export interface GatewaySettings {
-    /**
-     * Subsquid Network Gateway url
-     */
-    url: string
-    /**
-     * Request timeout in ms
-     */
-    requestTimeout?: number
-}
-
-
-export interface RpcSettings {
-    /**
-     * RPC client
-     */
-    client: SolanaRpcClient
-    /**
-     * `getBlock` batch call size.
-     *
-     * Default is `5`.
-     */
-    strideSize?: number
-    /**
-     * Maximum number of concurrent `getBlock` batch calls.
-     *
-     * Default is `10`
-     */
-    strideConcurrency?: number
-    /**
-     * Minimum distance from finalized head below which concurrent
-     * fetch procedure is allowed.
-     *
-     * Default is `50` blocks.
-     *
-     * Concurrent fetch procedure can perform multiple `getBlock` batch calls simultaneously and is faster,
-     * but assumes consistent behaviour of RPC endpoint.
-     *
-     * The latter might not be the case due to load balancing,
-     * when one request is sent to node `A` with head slot `X` and
-     * another to node `B` with head slot `X - 10`.
-     */
-    concurrentFetchThreshold?: number
+    SolanaQueryOptions,
+    FieldSelection,
+    mergeDataRequests,
+    mergeSelection,
+    Response,
+} from './query'
+import type {MergeSelection} from '@subsquid/util-internal'
+import {DataSource, DataSourceStream, DataSourceStreamData} from '@subsquid/data-source'
+import {getDataSchema} from './schema'
+
+export interface SolanaPortalDataSourceOptions<Q extends SolanaQueryOptions> {
+    portal: string | PortalClient
+    query: Q
 }
 
+export class SolanaPortalDataSource<
+    Q extends SolanaQueryOptions,
+    B extends BlockData<GetFields<Q['fields']>> = BlockData<GetFields<Q['fields']>>
+> implements DataSource<B>
+{
+    private portal: PortalClient
+    private fields: Q['fields']
+    private requests: RangeRequest<DataRequest>[]
 
-interface BlockRange {
-    range?: Range
-}
-
-
-export class DataSourceBuilder<F extends FieldSelection = {}> {
-    private requests: RangeRequest<DataRequest>[] = []
-    private fields?: FieldSelection
-    private blockRange?: Range
-    private archive?: GatewaySettings
-    private rpc?: RpcSettings
-
-    /**
-     * Set Subsquid Network Gateway endpoint (ex Archive).
-     *
-     * Subsquid Network allows to get data from finalized blocks up to
-     * infinite times faster and more efficient than via regular RPC.
-     *
-     * @example
-     * source.setGateway('https://v2.archive.subsquid.io/network/solana-mainnet')
-     */
-    setGateway(url: string | GatewaySettings): this {
-        if (typeof url == 'string') {
-            this.archive = {url}
-        } else {
-            this.archive = url
-        }
-        return this
-    }
-
-    /**
-     * Set up RPC data ingestion
-     */
-    setRpc(settings?: RpcSettings): this {
-        this.rpc = settings
-        return this
-    }
-
-    /**
-     * Limits the range of blocks to fetch.
-     *
-     * Note, that block heights should be used instead of slots.
-     */
-    setBlockRange(range?: Range): this {
-        this.blockRange = range
-        return this
-    }
-
-    /**
-     * Configure a set of fetched fields
-     */
-    setFields<F extends FieldSelection>(fields: F): DataSourceBuilder<F> {
-        this.fields = fields
-        return this as any
-    }
-
-    private add(range: Range | undefined, request: DataRequest): void {
-        this.requests.push({
-            range: range || {from: 0},
-            request
-        })
-    }
-
-    /**
-     * By default, blocks that doesn't contain requested items can be omitted.
-     * This method modifies such behaviour to fetch all chain blocks.
-     *
-     * Optionally a range of blocks can be specified
-     * for which the setting should be effective.
-     */
-    includeAllBlocks(range?: Range): this {
-        this.add(range, {includeAllBlocks: true})
-        return this
-    }
-
-    addTransaction(options: TransactionRequest & BlockRange): this {
-        let {range, ...req} = options
-        this.add(range, {
-            transactions: [req]
-        })
-        return this
-    }
-
-    addInstruction(options: InstructionRequest & BlockRange): this {
-        let {range, ...req} = options
-        this.add(range, {
-            instructions: [req]
-        })
-        return this
-    }
-
-    addLog(options: LogRequest & BlockRange): this {
-        let {range, ...req} = options
-        this.add(range, {
-            logs: [req]
-        })
-        return this
-    }
-
-    addBalance(options: BalanceRequest & BlockRange): this {
-        let {range, ...req} = options
-        this.add(range, {
-            balances: [req]
-        })
-        return this
+    constructor(options: SolanaPortalDataSourceOptions<Q>) {
+        this.portal = typeof options.portal === 'string' ? new PortalClient({url: options.portal}) : options.portal
+        this.fields = options.query.fields
+        this.requests = mergeRangeRequests(options.query.requests, mergeDataRequests)
     }
 
-    addTokenBalance(options: TokenBalanceRequest & BlockRange): this {
-        let {range, ...req} = options
-        this.add(range, {
-            tokenBalances: [req]
-        })
-        return this
+    getHeight(): Promise<number> {
+        return this.portal.getFinalizedHeight()
     }
 
-    addReward(options: RewardRequest & BlockRange): this {
-        let {range, ...req} = options
-        this.add(range, {
-            rewards: [req]
-        })
-        return this
+    getFinalizedHeight(): Promise<number> {
+        return this.portal.getFinalizedHeight()
     }
 
-    private getRequests(): RangeRequestList<DataRequest> {
-        function concat<T>(a?: T[], b?: T[]): T[] | undefined {
-            let result: T[] = []
-            if (a) {
-                result.push(...a)
-            }
-            if (b) {
-                result.push(...b)
-            }
-            return result.length == 0 ? undefined : result
-        }
-
-        let requests = mergeRangeRequests(this.requests, (a, b) => {
-            return {
-                includeAllBlocks: a.includeAllBlocks || b.includeAllBlocks,
-                transactions: concat(a.transactions, b.transactions),
-                instructions: concat(a.instructions, b.instructions),
-                logs: concat(a.logs, b.logs),
-                balances: concat(a.balances, b.balances),
-                tokenBalances: concat(a.tokenBalances, b.tokenBalances),
-                rewards: concat(a.rewards, b.rewards)
-            }
-        })
-
+    getBlockStream(range?: Range, stopOnHead?: boolean): DataSourceStream<B> {
         let fields = getFields(this.fields)
+        let requests = applyRangeBound(this.requests, range)
+
+        let {writable, readable} = new TransformStream<
+            PortalStreamData<BlockData<typeof fields>>,
+            DataSourceStreamData<B>
+        >({
+            transform: async (data, controller) => {
+                let blocks = data.map((b) => {
+                    let block = mapBlock(b, fields)
+                    Object.defineProperty(block, DataSource.blockRef, {
+                        value: {hash: block.header.hash, number: block.header.number},
+                    })
+                    return block
+                })
+
+                Object.defineProperty(blocks, DataSource.finalizedHead, {
+                    value: data[PortalClient.finalizedHead],
+                })
+
+                controller.enqueue(blocks as DataSourceStreamData<B>)
+            },
+        })
 
-        requests = requests.map(({range, request}) => {
-            return {
-                range,
-                request: {
+        const ingest = async () => {
+            for (let request of requests) {
+                let query = {
+                    type: 'solana',
+                    fromBlock: request.range.from,
+                    toBlock: request.range.to,
                     fields,
-                    ...request
+                    ...request.request,
                 }
-            }
-        })
-
-        return applyRangeBound(requests, this.blockRange)
-    }
-
-    build(): DataSource<Block<F>> {
-        return new SolanaDataSource(
-            this.getRequests(),
-            this.archive,
-            this.rpc
-        ) as DataSource<Block<F>>
-    }
-}
-
-
-export interface DataSource<Block> {
-    getFinalizedHeight(): Promise<number>
-    getBlockHash(height: number): Promise<Base58Bytes | undefined>
-    getBlocksCountInRange(range: FiniteRange): number
-    getBlockStream(fromBlockHeight?: number): AsyncIterable<Block[]>
-}
-
-
-export type GetDataSourceBlock<T> = T extends DataSource<infer B> ? B : never
 
-
-class SolanaDataSource implements DataSource<PartialBlock> {
-    private rpc?: RpcDataSource
-    private isConsistent?: boolean
-    private ranges: Range[]
-
-    constructor(
-        private requests: RangeRequestList<DataRequest>,
-        private archiveSettings?: GatewaySettings,
-        rpcSettings?: RpcSettings
-    ) {
-        assert(this.archiveSettings || rpcSettings, 'either archive or RPC should be provided')
-        if (rpcSettings) {
-            this.rpc = new RpcDataSource(rpcSettings)
-        }
-        this.ranges = this.requests.map(req => req.range)
-    }
-
-    getFinalizedHeight(): Promise<number> {
-        if (this.rpc) {
-            return this.rpc.getFinalizedHeight()
-        } else {
-            return this.createArchive().getFinalizedHeight()
-        }
-    }
-
-    async getBlockHash(height: number): Promise<Base58Bytes | undefined> {
-        await this.assertConsistency()
-        if (this.archiveSettings == null) {
-            assert(this.rpc)
-            return this.rpc.getBlockHash(height)
-        } else {
-            let archive = this.createArchive()
-            let head = await archive.getFinalizedHeight()
-            if (head >= height) return archive.getBlockHash(height)
-            if (this.rpc) return this.rpc.getBlockHash(height)
+                await this.portal.getFinalizedStream(query, {stopOnHead}).pipeTo(writable, {
+                    preventClose: true,
+                })
+            }
         }
-    }
 
-    private async assertConsistency(): Promise<void> {
-        if (this.isConsistent || this.archiveSettings == null || this.rpc == null) return
-        let blocks = await this.performConsistencyCheck().catch(err => {
-            throw addErrorContext(
-                new Error(`Failed to check consistency between Subsquid Gateway and RPC endpoints`),
-                {reason: err}
+        ingest()
+            .then(
+                () => writable.close(),
+                (reason) => writable.abort(reason)
             )
-        })
-        if (blocks == null) {
-            this.isConsistent = true
-        } else {
-            throw addErrorContext(
-                new Error(`Provided Subsquid Gateway and RPC endpoints don't agree on slot ${blocks.archiveBlock.slot}`),
-                blocks
-            )
-        }
-    }
-
-    private async performConsistencyCheck(): Promise<{
-        archiveBlock: BlockHeader
-        rpcBlock: BlockInfo | null
-    } | undefined> {
-        let archive = this.createArchive()
-        let height = await archive.getFinalizedHeight()
-        let archiveBlock = await archive.getBlockHeader(height)
-        let rpcBlock = await this.rpc!.getBlockInfo(archiveBlock.slot)
-        if (rpcBlock?.blockhash === archiveBlock.hash && rpcBlock.blockHeight === archiveBlock.height) return
-        return {archiveBlock, rpcBlock: rpcBlock || null}
-    }
+            .catch(() => {})
 
-    getBlocksCountInRange(range: FiniteRange): number {
-        return getSize(this.ranges, range)
+        return readable
     }
+}
 
-    async *getBlockStream(fromBlockHeight?: number): AsyncIterable<PartialBlock[]> {
-        await this.assertConsistency()
-
-        let requests = fromBlockHeight == null
-            ? this.requests
-            : applyRangeBound(this.requests, {from: fromBlockHeight})
-
-        if (requests.length == 0) return
-
-        if (this.archiveSettings) {
-            let agent = new HttpAgent({keepAlive: true})
-            try {
-                let archive = this.createArchive(agent)
-                let height = await archive.getFinalizedHeight()
-                let from = requests[0].range.from
-                if (height > from || !this.rpc) {
-                    for await (let batch of archive.getBlockStream(requests, !!this.rpc)) {
-                        yield batch
-                        from = last(batch).header.height + 1
-                    }
-                    requests = applyRangeBound(requests, {from})
-                }
-            } finally {
-                agent.close()
-            }
-        }
-
-        if (requests.length == 0) return
+export function mapBlock<F extends FieldSelection, B extends BlockData<F> = BlockData<F>>(
+    rawBlock: unknown,
+    fields: F
+): B {
+    let validator = getDataSchema(fields)
+    let block = cast(validator, rawBlock)
 
-        assert(this.rpc)
+    return block as unknown as B
+}
 
-        yield* this.rpc.getBlockStream(requests)
-    }
+function getFields<T extends FieldSelection>(fields: T): GetFields<T> {
+    return mergeSelection(REQUIRED_FIELDS, fields)
+}
 
-    private createArchive(agent?: HttpAgent): SolanaArchive {
-        assert(this.archiveSettings)
+type GetFields<F extends FieldSelection> = MergeSelection<ReqiredFieldSelection, F>
 
-        let http = new HttpClient({
-            headers: {
-                'x-squid-id': this.getSquidId()
-            },
-            agent
-        })
-
-        return new SolanaArchive(
-            new ArchiveClient({
-                http,
-                url: this.archiveSettings.url,
-                queryTimeout: this.archiveSettings.requestTimeout,
-            })
-        )
-    }
+type ReqiredFieldSelection = typeof REQUIRED_FIELDS
 
-    @def
-    private getSquidId(): string {
-        return getOrGenerateSquidId()
-    }
-}
+const REQUIRED_FIELDS = {
+    block: {
+        number: true,
+        hash: true,
+        parentHash: true,
+    },
+} as const satisfies FieldSelection

package/README.md

@@ -1,4 +0,0 @@
-# @subsquid/solana-stream
-
-Solana block data source, that allows to request and fetch block data from both Subsquid Network 
-and traditional RPC endpoint.

package/lib/archive/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/archive/schema.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAA;AAG5C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHxB,CAAA"}

package/lib/archive/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/archive/schema.ts"],"names":[],"mappings":"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"}

package/lib/archive/source.d.ts

@@ -1,15 +0,0 @@
-import { BlockHeader } from '@subsquid/solana-normalization';
-import { Base58Bytes } from '@subsquid/solana-rpc-data';
-import { ArchiveClient } from '@subsquid/util-internal-archive-client';
-import { RangeRequestList } from '@subsquid/util-internal-range';
-import { PartialBlock } from '../data/partial';
-import { DataRequest } from '../data/request';
-export declare class SolanaArchive {
-    private client;
-    constructor(client: ArchiveClient);
-    getFinalizedHeight(): Promise<number>;
-    getBlockHash(height: number): Promise<Base58Bytes | undefined>;
-    getBlockHeader(height: number): Promise<BlockHeader>;
-    getBlockStream(requests: RangeRequestList<DataRequest>, stopOnHead?: boolean | undefined): AsyncIterable<PartialBlock[]>;
-}
-//# sourceMappingURL=source.d.ts.map

package/lib/archive/source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/archive/source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAA;AAC1D,OAAO,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAA;AAErD,OAAO,EAAC,aAAa,EAAC,MAAM,wCAAwC,CAAA;AAEpE,OAAO,EAAoC,gBAAgB,EAAC,MAAM,+BAA+B,CAAA;AAGjG,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAA;AAI3C,qBAAa,aAAa;IACV,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEzC,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI/B,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAW9D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAuBnD,cAAc,CAAC,QAAQ,EAAE,gBAAgB,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,aAAa,CAAC,YAAY,EAAE,CAAC;CAkDlI"}

package/lib/archive/source.js

@@ -1,98 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaArchive = void 0;
-const util_internal_1 = require("@subsquid/util-internal");
-const util_internal_ingest_tools_1 = require("@subsquid/util-internal-ingest-tools");
-const util_internal_range_1 = require("@subsquid/util-internal-range");
-const util_internal_validation_1 = require("@subsquid/util-internal-validation");
-const assert_1 = __importDefault(require("assert"));
-const schema_1 = require("./schema");
-class SolanaArchive {
-    constructor(client) {
-        this.client = client;
-    }
-    getFinalizedHeight() {
-        return this.client.getHeight();
-    }
-    async getBlockHash(height) {
-        let blocks = await this.client.query({
-            type: 'solana',
-            fromBlock: height,
-            toBlock: height,
-            includeAllBlocks: true
-        });
-        (0, assert_1.default)(blocks.length == 1);
-        return blocks[0].header.hash;
-    }
-    async getBlockHeader(height) {
-        let blocks = await this.client.query({
-            type: 'solana',
-            fromBlock: height,
-            toBlock: height,
-            includeAllBlocks: true,
-            fields: {
-                block: {
-                    slot: true,
-                    parentSlot: true,
-                    parentHash: true,
-                    timestamp: true
-                }
-            }
-        });
-        (0, assert_1.default)(blocks.length == 1);
-        let { number, ...rest } = blocks[0].header;
-        return {
-            height: number,
-            ...rest
-        };
-    }
-    async *getBlockStream(requests, stopOnHead) {
-        let archiveRequests = (0, util_internal_range_1.mapRangeRequestList)(requests, req => {
-            let { fields, includeAllBlocks, ...items } = req;
-            let archiveItems = {};
-            let key;
-            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 (0, util_internal_ingest_tools_1.archiveIngest)({
-            client: this.client,
-            requests: archiveRequests,
-            stopOnHead
-        })) {
-            let req = (0, util_internal_range_1.getRequestAt)(requests, batch.blocks[0].header.number);
-            let blocks = (0, util_internal_validation_1.cast)((0, util_internal_validation_1.array)((0, schema_1.getDataSchema)((0, util_internal_1.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;
-        }
-    }
-}
-exports.SolanaArchive = SolanaArchive;
-//# sourceMappingURL=source.js.map

package/lib/archive/source.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"source.js","sourceRoot":"","sources":["../../src/archive/source.ts"],"names":[],"mappings":"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"}

package/lib/data/fields.d.ts

@@ -1,8 +0,0 @@
-import { FieldSelection } from './model';
-import { Selector } from './type-util';
-/**
- * Get effective set of selected fields.
- */
-export declare function getFields(fields: FieldSelection | undefined): FieldSelection;
-export declare function project<T>(fields: Selector<keyof T> | undefined, obj: T): Partial<T>;
-//# sourceMappingURL=fields.d.ts.map

package/lib/data/fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/data/fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,cAAc,EAAC,MAAM,SAAS,CAAA;AACtD,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAA;AAGpC;;GAEG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,cAAc,CAU5E;AAsBD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUpF"}