@subsquid/portal-client 0.3.0 → 0.4.0

package/src/query/index.ts

@@ -1,50 +1,33 @@
 import {unexpectedCase} from '@subsquid/util-internal'
-import {Simplify} from './common'
 import * as evm from './evm'
 import * as solana from './solana'
 import * as substrate from './substrate'
-import {Validator} from '@subsquid/util-internal-validation'
 
-export type {PortalBlock, PortalQuery} from './common'
-export type {evm, solana, substrate}
+export {evm, solana, substrate}
 
-export type Query = evm.Query | solana.Query | substrate.Query
+export type GetQueryBlock<Q> = Q extends evm.Query<infer F>
+    ? evm.Block<F>
+    : Q extends solana.Query<infer F>
+    ? solana.Block<F>
+    : Q extends substrate.Query<infer F>
+    ? substrate.Block<F>
+    : never
 
-export type GetBlock<Q extends Query> = Q extends evm.Query
-    ? evm.Block<Q['fields']>
-    : Q extends solana.Query
-    ? solana.Block<Q['fields']>
-    : substrate.Block<Q['fields']>
-
-export function createQuery<Q extends Query>(query: Q): Simplify<Q & Query> {
-    return {
-        ...query,
-        type: query.type,
-        fields: query.fields,
-    }
-}
-
-const BLOCK_SCHEMAS = new WeakMap<Query, Validator<any, any>>()
-
-export function getBlockSchema<Q extends Query>(query: Q): Validator<GetBlock<Q>, any> {
-    let schema = BLOCK_SCHEMAS.get(query)
-    if (schema) return schema
+export type AnyQuery = evm.Query | solana.Query | substrate.Query
 
+export function getQuery<Q extends AnyQuery>(query: Q) {
+    query = {...query}
     switch (query.type) {
-        case 'solana':
-            schema = solana.getBlockSchema(query.fields)
-            break
         case 'evm':
-            schema = evm.getBlockSchema(query.fields)
-            break
+            query.fields = evm.patchQueryFields(query.fields ?? {})
+            return [query, evm.getBlockSchema(query.fields)] as const
+        case 'solana':
+            query.fields = solana.patchQueryFields(query.fields ?? {})
+            return [query, solana.getBlockSchema(query.fields)] as const
         case 'substrate':
-            schema = substrate.getBlockSchema(query.fields)
-            break
+            query.fields = substrate.patchQueryFields(query.fields ?? {})
+            return [query, substrate.getBlockSchema(query.fields)] as const
         default:
-            throw unexpectedCase(query['type'])
+            throw unexpectedCase((query as any).type)
     }
-
-    BLOCK_SCHEMAS.set(query, schema)
-
-    return schema
 }

package/src/query/solana/data.ts

@@ -0,0 +1,132 @@
+import type {Base58Bytes} from '../common/data'
+
+export interface BlockHeader {
+    number: number
+    hash: Base58Bytes
+    parentNumber: number
+    parentHash: Base58Bytes
+    height: number
+    timestamp: number
+}
+
+export interface Transaction {
+    /**
+     * Transaction position in block
+     */
+    transactionIndex: number
+    version: 'legacy' | number
+    // transaction message
+    accountKeys: Base58Bytes[]
+    addressTableLookups: AddressTableLookup[]
+    numReadonlySignedAccounts: number
+    numReadonlyUnsignedAccounts: number
+    numRequiredSignatures: number
+    recentBlockhash: Base58Bytes
+    signatures: Base58Bytes[]
+    // meta fields
+    err: null | object
+    computeUnitsConsumed: bigint
+    fee: bigint
+    loadedAddresses: {
+        readonly: Base58Bytes[]
+        writable: Base58Bytes[]
+    }
+    hasDroppedLogMessages: boolean
+}
+
+export interface AddressTableLookup {
+    accountKey: Base58Bytes
+    readonlyIndexes: number[]
+    writableIndexes: number[]
+}
+
+export interface Instruction {
+    transactionIndex: number
+    instructionAddress: number[]
+    programId: Base58Bytes
+    accounts: Base58Bytes[]
+    data: Base58Bytes
+    // execution result extracted from logs
+    computeUnitsConsumed?: bigint
+    error?: string
+    /**
+     * `true` when transaction completed successfully, `false` otherwise
+     */
+    isCommitted: boolean
+    hasDroppedLogMessages: boolean
+}
+
+export interface LogMessage {
+    transactionIndex: number
+    logIndex: number
+    instructionAddress: number[]
+    programId: Base58Bytes
+    kind: 'log' | 'data' | 'other'
+    message: string
+}
+
+export interface Balance {
+    transactionIndex: number
+    account: Base58Bytes
+    pre: bigint
+    post: bigint
+}
+
+export type TokenBalance = PreTokenBalance | PostTokenBalance | PrePostTokenBalance
+
+export interface PreTokenBalance {
+    transactionIndex: number
+    account: Base58Bytes
+
+    preProgramId?: Base58Bytes
+    preMint: Base58Bytes
+    preDecimals: number
+    preOwner?: Base58Bytes
+    preAmount: bigint
+
+    postProgramId?: undefined
+    postMint?: undefined
+    postDecimals?: undefined
+    postOwner?: undefined
+    postAmount?: undefined
+}
+
+export interface PostTokenBalance {
+    transactionIndex: number
+    account: Base58Bytes
+
+    preProgramId?: undefined
+    preMint?: undefined
+    preDecimals?: undefined
+    preOwner?: undefined
+    preAmount?: undefined
+
+    postProgramId?: Base58Bytes
+    postMint: Base58Bytes
+    postDecimals: number
+    postOwner?: Base58Bytes
+    postAmount: bigint
+}
+
+export interface PrePostTokenBalance {
+    transactionIndex: number
+    account: Base58Bytes
+    preProgramId?: Base58Bytes
+    preMint: Base58Bytes
+    preDecimals: number
+    preOwner?: Base58Bytes
+    preAmount: bigint
+    postProgramId?: Base58Bytes
+    postMint: Base58Bytes
+    postDecimals: number
+    postOwner?: Base58Bytes
+    postAmount: bigint
+}
+
+export interface Reward {
+    pubkey: Base58Bytes
+    lamports: bigint
+    postBalance: bigint
+    rewardType?: string
+    commission?: number
+}

package/src/query/solana/fields.ts

@@ -0,0 +1,42 @@
+import type {GetFields, Select, Selector, Simplify} from '../type-util'
+import type * as data from './data'
+
+type BlockRequiredFields = 'number' | 'hash' | 'parentHash' | 'parentNumber'
+
+export interface FieldSelection {
+    block?: Selector<Exclude<keyof data.BlockHeader, BlockRequiredFields>>
+    transaction?: Selector<keyof data.Transaction>
+    instruction?: Selector<keyof data.Instruction>
+    log?: Selector<keyof data.LogMessage>
+    balance?: Selector<keyof data.Balance>
+    tokenBalance?: Selector<keyof data.TokenBalance>
+    reward?: Selector<keyof data.Reward>
+}
+
+export type BlockHeader<F extends FieldSelection> = Simplify<
+    Pick<data.BlockHeader, BlockRequiredFields> & Select<data.BlockHeader, GetFields<F['block']>>
+>
+
+type Item<T, F extends FieldSelection, K extends keyof F> = Select<T, GetFields<F[K]>>
+
+export type Transaction<F extends FieldSelection> = Item<data.Transaction, F, 'transaction'>
+
+export type Instruction<F extends FieldSelection> = Item<data.Instruction, F, 'instruction'>
+
+export type LogMessage<F extends FieldSelection> = Item<data.LogMessage, F, 'log'>
+
+export type Balance<F extends FieldSelection> = Item<data.Balance, F, 'balance'>
+
+export type TokenBalance<F extends FieldSelection> = Item<data.TokenBalance, F, 'tokenBalance'>
+
+export type Reward<F extends FieldSelection> = Item<data.Reward, 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/query/solana/index.ts

@@ -0,0 +1,3 @@
+export type * from './fields'
+export type * from './query'
+export {getBlockSchema, patchQueryFields} from './schema'

package/src/query/solana/query.ts

@@ -0,0 +1,89 @@
+import type {QueryBase} from '../common/query'
+import type {Base58Bytes} from '../common/data'
+import type {LogMessage} from './data'
+import type {FieldSelection} from './fields'
+
+
+export interface Query<F extends FieldSelection = FieldSelection> extends QueryBase, ItemQuery {
+    type: 'solana'
+    fields: F
+}
+
+
+export interface ItemQuery {
+    transactions?: TransactionRequest[]
+    instructions?: InstructionRequest[]
+    logs?: LogRequest[]
+    balances?: BalanceRequest[]
+    tokenBalances?: TokenBalanceRequest[]
+    rewards?: RewardRequest[]
+}
+
+
+export interface TransactionRequest {
+    feePayer?: Base58Bytes[]
+    instructions?: boolean
+    logs?: boolean
+}
+
+
+export interface InstructionRequest {
+    programId?: Base58Bytes[]
+    discriminator?: string[]
+    a0?: Base58Bytes[]
+    a1?: Base58Bytes[]
+    a2?: Base58Bytes[]
+    a3?: Base58Bytes[]
+    a4?: Base58Bytes[]
+    a5?: Base58Bytes[]
+    a6?: Base58Bytes[]
+    a7?: Base58Bytes[]
+    a8?: Base58Bytes[]
+    a9?: Base58Bytes[]
+    a10?: Base58Bytes[]
+    a11?: Base58Bytes[]
+    a12?: Base58Bytes[]
+    a13?: Base58Bytes[]
+    a14?: Base58Bytes[]
+    a15?: Base58Bytes[]
+    isCommitted?: boolean
+    transaction?: boolean
+    transactionBalances?: boolean
+    transactionTokenBalances?: boolean
+    transactionInstructions?: boolean
+    logs?: boolean
+    innerInstructions?: boolean
+}
+
+
+export interface LogRequest {
+    programId?: Base58Bytes[]
+    kind?: LogMessage['kind'][]
+    transaction?: boolean
+    instruction?: boolean
+}
+
+
+export interface BalanceRequest {
+    account?: Base58Bytes[]
+    transaction?: boolean
+    transactionInstructions?: boolean
+}
+
+
+export interface TokenBalanceRequest {
+    account?: Base58Bytes[]
+    preProgramId?: Base58Bytes[]
+    postProgramId?: Base58Bytes[]
+    preMint?: Base58Bytes[]
+    postMint?: Base58Bytes[]
+    preOwner?: Base58Bytes[]
+    postOwner?: Base58Bytes[]
+    transaction?: boolean
+    transactionInstructions?: boolean
+}
+
+
+export interface RewardRequest {
+    pubkey?: Base58Bytes[]
+}

package/src/query/solana/schema.ts

@@ -0,0 +1,164 @@
+import {
+    ANY_OBJECT,
+    array,
+    B58,
+    BIG_NAT,
+    BOOLEAN,
+    constant,
+    NAT,
+    nullable,
+    object,
+    oneOf,
+    option,
+    STRING,
+    withDefault,
+} from '@subsquid/util-internal-validation'
+import {project} from '../util'
+import type {FieldSelection} from './fields'
+
+export function patchQueryFields(fields: FieldSelection): FieldSelection {
+    fields = {...fields}
+    let {height, ...block} = (fields.block as any) ?? {}
+    fields.block = {
+        ...block,
+        number: true,
+        hash: true,
+        parentHash: true,
+    }
+    return fields
+}
+
+export function getBlockSchema(fields: FieldSelection) {
+    return object({
+        header: getBlockHeaderSchema(fields),
+        transactions: withDefault([], array(getTransactionSchema(fields))),
+        instructions: withDefault([], array(getInstructionSchema(fields))),
+        logs: withDefault([], array(getLogSchema(fields))),
+        balances: withDefault([], array(getBalanceSchema(fields))),
+        tokenBalances: withDefault([], array(getTokenBalanceSchema(fields))),
+        rewards: withDefault([], array(getRewardSchema(fields))),
+    })
+}
+
+function getBlockHeaderSchema(fields: FieldSelection) {
+    return object({
+        number: NAT,
+        hash: B58,
+        parentHash: B58,
+        ...project(fields.block, {
+            parentSlot: NAT,
+            height: NAT,
+            timestamp: NAT,
+        }),
+    })
+}
+
+const AddressTableLookup = object({
+    accountKey: B58,
+    readonlyIndexes: array(NAT),
+    writableIndexes: array(NAT),
+})
+
+function getTransactionSchema(fields: FieldSelection) {
+    return object(
+        project(fields.transaction, {
+            transactionIndex: NAT,
+            version: oneOf({
+                legacy: constant('legacy'),
+                versionNumber: NAT,
+            }),
+            accountKeys: array(B58),
+            addressTableLookups: array(AddressTableLookup),
+            numReadonlySignedAccounts: NAT,
+            numReadonlyUnsignedAccounts: NAT,
+            numRequiredSignatures: NAT,
+            recentBlockhash: B58,
+            signatures: array(B58),
+            err: nullable(ANY_OBJECT),
+            computeUnitsConsumed: BIG_NAT,
+            fee: BIG_NAT,
+            loadedAddresses: option(
+                object({
+                    readonly: array(B58),
+                    writable: array(B58),
+                })
+            ),
+            hasDroppedLogMessages: BOOLEAN,
+        })
+    )
+}
+
+function getInstructionSchema(fields: FieldSelection) {
+    return object(
+        project(fields.instruction, {
+            transactionIndex: NAT,
+            instructionAddress: array(NAT),
+            programId: B58,
+            accounts: array(B58),
+            data: B58,
+            computeUnitsConsumed: option(BIG_NAT),
+            error: option(STRING),
+            isCommitted: BOOLEAN,
+            hasDroppedLogMessages: BOOLEAN,
+        })
+    )
+}
+
+function getLogSchema(fields: FieldSelection) {
+    return object(
+        project(fields.log, {
+            transactionIndex: NAT,
+            logIndex: NAT,
+            instructionAddress: array(NAT),
+            programId: B58,
+            kind: oneOf({
+                log: constant('log'),
+                data: constant('data'),
+                other: constant('other'),
+            }),
+            message: STRING,
+        })
+    )
+}
+
+function getBalanceSchema(fields: FieldSelection) {
+    return object(
+        project(fields.balance, {
+            transactionIndex: NAT,
+            account: B58,
+            pre: BIG_NAT,
+            post: BIG_NAT,
+        })
+    )
+}
+
+function getTokenBalanceSchema(fields: FieldSelection) {
+    return object(
+        project(fields.tokenBalance, {
+            transactionIndex: NAT,
+            account: B58,
+            preProgramId: option(B58),
+            postProgramId: option(B58),
+            preMint: option(B58),
+            postMint: option(B58),
+            preDecimals: option(NAT),
+            postDecimals: option(NAT),
+            preOwner: option(B58),
+            postOwner: option(B58),
+            preAmount: option(BIG_NAT),
+            postAmount: option(BIG_NAT),
+        })
+    )
+}
+
+function getRewardSchema(fields: FieldSelection) {
+    return object(
+        project(fields.reward, {
+            pubkey: B58,
+            lamports: BIG_NAT,
+            postBalance: BIG_NAT,
+            rewardType: option(STRING),
+            commission: option(NAT),
+        })
+    )
+}

package/src/query/substrate/data.ts

@@ -0,0 +1,101 @@
+import type {Bytes} from '../common/data'
+
+/**
+ * @example 'Balances.Transfer'
+ */
+export type QualifiedName = string & {}
+
+export interface BlockHeader {
+    /**
+     * Block number (height)
+     */
+    number: number
+    /**
+     * Block hash
+     */
+    hash: Bytes
+    /**
+     * Hash of the parent block
+     */
+    parentHash: Bytes
+    /**
+     * Root hash of the state merkle tree
+     */
+    stateRoot: Bytes
+    /**
+     * Root hash of the extrinsics merkle tree
+     */
+    extrinsicsRoot: Bytes
+    digest: {logs: Bytes[]}
+    specName: string
+    specVersion: number
+    implName: string
+    implVersion: number
+    /**
+     * Block timestamp as set by `timestamp.now()` (unix epoch ms, compatible with `Date`).
+     */
+    timestamp?: number
+    /**
+     * Account address of block validator
+     */
+    validator?: Bytes
+}
+
+export interface ExtrinsicSignature {
+    address: Bytes
+    signature: unknown
+    signedExtensions: unknown
+}
+
+export interface Extrinsic {
+    /**
+     * Ordinal index in the extrinsics array of the current block
+     */
+    index: number
+    version: number
+    signature?: ExtrinsicSignature
+    fee?: bigint
+    tip?: bigint
+    error?: unknown
+    success?: boolean
+    /**
+     * Blake2b 128-bit hash of the raw extrinsic
+     */
+    hash?: Bytes
+}
+
+export interface Call {
+    extrinsicIndex: number
+    address: number[]
+    name: QualifiedName
+    args: unknown
+    origin?: unknown
+    /**
+     * Call error.
+     *
+     * Absence of error doesn't imply that the call was executed successfully,
+     * check {@link success} property for that.
+     */
+    error?: unknown
+    success?: boolean
+}
+
+export interface Event {
+    /**
+     * Ordinal index in the event array of the current block
+     */
+    index: number
+    /**
+     * Event name
+     */
+    name: QualifiedName
+    args: unknown
+    phase: 'Initialization' | 'ApplyExtrinsic' | 'Finalization'
+    extrinsicIndex?: number
+    callAddress?: number[]
+    /**
+     * This field is not supported by all currently deployed archives.
+     * Requesting it may cause internal error.
+     */
+    topics: Bytes[]
+}

package/src/query/substrate/fields.ts

@@ -0,0 +1,30 @@
+import type {GetFields, Select, Selector, Simplify} from '../type-util'
+import type * as data from './data'
+
+type BlockRequiredFields = 'number' | 'hash'
+
+export interface FieldSelection {
+    block?: Selector<Exclude<keyof data.BlockHeader, BlockRequiredFields>>
+    extrinsic?: Selector<keyof data.Extrinsic>
+    call?: Selector<keyof data.Call>
+    event?: Selector<keyof data.Event>
+}
+
+export type BlockHeader<F extends FieldSelection> = Simplify<
+    Pick<data.BlockHeader, BlockRequiredFields> & Select<data.BlockHeader, GetFields<F['block']>>
+>
+
+type Item<T, F extends FieldSelection, K extends keyof F> = Select<T, GetFields<F[K]>>
+
+export type Extrinsic<F extends FieldSelection> = Item<data.Extrinsic, F, 'extrinsic'>
+
+export type Call<F extends FieldSelection> = Item<data.Call, F, 'call'>
+
+export type Event<F extends FieldSelection> = Item<data.Event, F, 'event'>
+
+export interface Block<F extends FieldSelection> {
+    header: BlockHeader<F>
+    extrinsics: Extrinsic<F>[]
+    calls: Call<F>[]
+    events: Event<F>[]
+}

package/src/query/substrate/index.ts

@@ -0,0 +1,3 @@
+export type * from './fields'
+export type * from './query'
+export {getBlockSchema, patchQueryFields} from './schema'

package/src/query/substrate/query.ts

@@ -0,0 +1,60 @@
+import type {QueryBase} from '../common/query'
+import type {Bytes} from '../common/data'
+import type {FieldSelection} from './fields'
+import type {QualifiedName} from './data'
+
+export interface Query<F extends FieldSelection = FieldSelection> extends QueryBase, ItemQuery {
+    type: 'substrate'
+    fields?: F
+}
+
+export interface ItemQuery {
+    events?: EventRequest[]
+    calls?: CallRequest[]
+    evmLogs?: EvmLogRequest[]
+    ethereumTransactions?: EthereumTransactRequest[]
+    contractsEvents?: ContractsContractEmittedRequest[]
+    gearMessagesQueued?: GearMessageQueuedRequest[]
+    gearUserMessagesSent?: GearUserMessageSentRequest[]
+}
+
+export interface EventRelations {
+    extrinsic?: boolean
+    call?: boolean
+    stack?: boolean
+}
+
+export interface EventRequest extends EventRelations {
+    name?: QualifiedName[]
+}
+
+export interface CallRelations {
+    extrinsic?: boolean
+    stack?: boolean
+    events?: boolean
+}
+
+export interface CallRequest extends CallRelations {
+    name?: QualifiedName[]
+}
+
+export interface EvmLogRequest extends EventRelations {
+    address?: Bytes[]
+}
+
+export interface EthereumTransactRequest extends CallRelations {
+    to?: Bytes[]
+    sighash?: Bytes[]
+}
+
+export interface ContractsContractEmittedRequest extends EventRelations {
+    address?: Bytes[]
+}
+
+export interface GearMessageQueuedRequest extends EventRelations {
+    programId?: Bytes[]
+}
+
+export interface GearUserMessageSentRequest extends EventRelations {
+    programId?: Bytes[]
+}