@subsquid/portal-client 0.3.2 → 0.4.0

package/src/query/common/data.ts

@@ -0,0 +1,24 @@
+/**
+ * Hex binary string
+ */
+export type Bytes = string & {}
+
+/**
+ * 32 bytes as a hex string
+ */
+export type Bytes32 = string & {}
+
+/**
+ * 20 bytes as a hex string
+ */
+export type Bytes20 = string & {}
+
+/**
+ * 8 bytes as a hex string
+ */
+export type Bytes8 = string & {}
+
+/**
+ * Base58 encoded byte string
+ */
+export type Base58Bytes = string & {}

package/src/query/common/query.ts

@@ -0,0 +1,6 @@
+export interface QueryBase {
+    fromBlock: number
+    toBlock?: number
+    parentBlockHash?: string
+    includeAllBlocks?: boolean
+}

package/src/query/evm/data.ts

@@ -0,0 +1,182 @@
+import type {Bytes, Bytes20, Bytes32, Bytes8} from '../common/data'
+
+export interface BlockHeader {
+    number: number
+    hash: Bytes32
+    parentHash: Bytes32
+    nonce: Bytes8
+    sha3Uncles: Bytes32
+    logsBloom: Bytes
+    transactionsRoot: Bytes32
+    stateRoot: Bytes32
+    receiptsRoot: Bytes32
+    mixHash: Bytes
+    miner: Bytes20
+    difficulty: bigint
+    totalDifficulty: bigint
+    extraData: Bytes
+    size: bigint
+    gasLimit: bigint
+    gasUsed: bigint
+    timestamp: number
+    baseFeePerGas: bigint
+    l1BlockNumber: number
+}
+
+export interface Transaction {
+    transactionIndex: number
+    // Transaction part
+    hash: Bytes32
+    from: Bytes20
+    to?: Bytes20
+    gas: bigint
+    gasPrice: bigint
+    maxFeePerGas?: bigint
+    maxPriorityFeePerGas?: bigint
+    input: Bytes
+    sighash?: Bytes8
+    nonce: number
+    value: bigint
+    v: bigint
+    r: Bytes32
+    s: Bytes32
+    yParity?: number
+    chainId?: number
+    authorizationList?: EIP7702Authorization[]
+    // Receipt part
+    gasUsed: bigint
+    cumulativeGasUsed: bigint
+    effectiveGasPrice: bigint
+    contractAddress?: Bytes20
+    type: number
+    status: number
+    l1Fee?: bigint
+    l1FeeScalar?: number
+    l1GasPrice?: bigint
+    l1GasUsed?: bigint
+    l1BlobBaseFee?: bigint
+    l1BlobBaseFeeScalar?: number
+    l1BaseFeeScalar?: number
+}
+
+export interface EIP7702Authorization {
+    chainId: number
+    nonce: number
+    address: Bytes20
+    yParity: number
+    r: Bytes32
+    s: Bytes32
+}
+
+export interface Log {
+    logIndex: number
+    transactionIndex: number
+    transactionHash: Bytes32
+    address: Bytes20
+    topics: Bytes32[]
+    data: Bytes
+}
+
+export interface TraceBase {
+    transactionIndex: number
+    traceAddress: number[]
+    subtraces: number
+    error: string | null
+    revertReason?: string
+}
+
+export interface TraceCreate extends TraceBase {
+    type: 'create'
+    action: TraceCreateAction
+    result?: TraceCreateResult
+}
+
+export interface TraceCreateAction {
+    from: Bytes20
+    value: bigint
+    gas: bigint
+    init: Bytes
+}
+
+export interface TraceCreateResult {
+    gasUsed: bigint
+    code: Bytes
+    address: Bytes20
+}
+
+export interface TraceCall extends TraceBase {
+    type: 'call'
+    action: TraceCallAction
+    result?: TraceCallResult
+}
+
+export interface TraceCallAction {
+    callType: string
+    from: Bytes20
+    to: Bytes20
+    value?: bigint
+    gas: bigint
+    input: Bytes
+    sighash: Bytes8
+}
+
+export interface TraceCallResult {
+    gasUsed: bigint
+    output: Bytes
+}
+
+export interface TraceSuicide extends TraceBase {
+    type: 'suicide'
+    action: TraceSuicideAction
+}
+
+export interface TraceSuicideAction {
+    address: Bytes20
+    refundAddress: Bytes20
+    balance: bigint
+}
+
+export interface TraceReward extends TraceBase {
+    type: 'reward'
+    action: TraceRewardAction
+}
+
+export interface TraceRewardAction {
+    author: Bytes20
+    value: bigint
+    type: string
+}
+
+export type Trace = TraceCreate | TraceCall | TraceSuicide | TraceReward
+
+export interface StateDiffBase {
+    transactionIndex: number
+    address: Bytes20
+    key: 'balance' | 'code' | 'nonce' | Bytes32
+}
+
+export interface StateDiffNoChange extends StateDiffBase {
+    kind: '='
+    prev?: null
+    next?: null
+}
+
+export interface StateDiffAdd extends StateDiffBase {
+    kind: '+'
+    prev?: null
+    next: Bytes32
+}
+
+export interface StateDiffChange extends StateDiffBase {
+    kind: '*'
+    prev: Bytes32
+    next: Bytes32
+}
+
+export interface StateDiffDelete extends StateDiffBase {
+    kind: '-'
+    prev: Bytes32
+    next?: null
+}
+
+export type StateDiff = StateDiffNoChange | StateDiffAdd | StateDiffChange | StateDiffDelete

package/src/query/evm/fields.ts

@@ -0,0 +1,105 @@
+import type {AddPrefix, GetFields, RemovePrefix, Select, Selector, Simplify} from '../type-util'
+import type * as data from './data'
+
+type BlockRequiredFields = 'number' | 'hash' | 'parentHash'
+
+export interface FieldSelection {
+    block?: Selector<Exclude<keyof data.BlockHeader, BlockRequiredFields>>
+    transaction?: Selector<keyof data.Transaction>
+    log?: Selector<keyof data.Log>
+    trace?: Selector<
+        | keyof data.TraceBase
+        | AddPrefix<'create', keyof data.TraceCreateAction>
+        | AddPrefix<'createResult', keyof data.TraceCreateResult>
+        | AddPrefix<'call', keyof data.TraceCallAction>
+        | AddPrefix<'callResult', keyof data.TraceCallResult>
+        | AddPrefix<'suicide', keyof data.TraceSuicideAction>
+        | AddPrefix<'reward', keyof data.TraceRewardAction>
+    >
+    stateDiff?: Selector<Exclude<keyof data.StateDiff, 'kind'>>
+}
+
+export type BlockHeader<F extends FieldSelection> = Simplify<
+    Pick<data.BlockHeader, BlockRequiredFields> & Select<data.BlockHeader, GetFields<F['block']>>
+>
+
+export type Transaction<F extends FieldSelection> = Select<data.Transaction, GetFields<F['transaction']>>
+
+export type Log<F extends FieldSelection> = Select<data.Log, GetFields<F['log']>>
+
+export type TraceCreateAction<F extends FieldSelection> = Select<
+    data.TraceCreateAction,
+    RemovePrefix<'create', GetFields<F['trace']>>
+>
+
+export type TraceCreateResult<F extends FieldSelection> = Select<
+    data.TraceCreateResult,
+    RemovePrefix<'createResult', GetFields<F['trace']>>
+>
+
+export type TraceCallAction<F extends FieldSelection> = Select<
+    data.TraceCallAction,
+    RemovePrefix<'call', GetFields<F['trace']>>
+>
+
+export type TraceCallResult<F extends FieldSelection> = Select<
+    data.TraceCallResult,
+    RemovePrefix<'callResult', GetFields<F['trace']>>
+>
+
+export type TraceSuicideAction<F extends FieldSelection> = Select<
+    data.TraceSuicideAction,
+    RemovePrefix<'suicide', GetFields<F['trace']>>
+>
+
+export type TraceRewardAction<F extends FieldSelection> = Select<
+    data.TraceRewardAction,
+    RemovePrefix<'reward', GetFields<F['trace']>>
+>
+
+type TraceBase<F extends FieldSelection, Type> = {type: Type} & Select<data.TraceBase, GetFields<F['trace']>>
+
+type RemoveEmptyObjects<T> = {
+    [K in keyof T as {} extends T[K] ? never : K]: T[K]
+}
+
+export type TraceCreate<F extends FieldSelection> = Simplify<
+    TraceBase<F, 'create'> &
+        RemoveEmptyObjects<{
+            action: TraceCreateAction<F>
+            result?: TraceCreateResult<F>
+        }>
+>
+
+export type TraceCall<F extends FieldSelection> = Simplify<
+    TraceBase<F, 'call'> &
+        RemoveEmptyObjects<{
+            action: TraceCallAction<F>
+            result?: TraceCallResult<F>
+        }>
+>
+
+export type TraceSuicide<F extends FieldSelection> = Simplify<
+    TraceBase<F, 'suicide'> &
+        RemoveEmptyObjects<{
+            action: TraceSuicideAction<F>
+        }>
+>
+
+export type TraceReward<F extends FieldSelection> = Simplify<
+    TraceBase<F, 'reward'> & RemoveEmptyObjects<{action: TraceRewardAction<F>}>
+>
+
+export type Trace<F extends FieldSelection> = TraceCreate<F> | TraceCall<F> | TraceSuicide<F> | TraceReward<F>
+
+export type StateDiff<F extends FieldSelection> = Simplify<
+    Pick<data.StateDiff, 'kind'> & Select<data.StateDiff, GetFields<F['stateDiff']>>
+>
+
+export interface Block<F extends FieldSelection> {
+    header: BlockHeader<F>
+    transactions: Transaction<F>[]
+    logs: Log<F>[]
+    traces: Trace<F>[]
+    stateDiffs: StateDiff<F>[]
+}

package/src/query/evm/index.ts

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

package/src/query/evm/query.ts

@@ -0,0 +1,59 @@
+import type {Bytes, Bytes20, Bytes32, Bytes8} from '../common/data'
+import type {QueryBase} from '../common/query'
+import type {StateDiff} from './data'
+import type {FieldSelection} from './fields'
+
+export interface Query<F extends FieldSelection = FieldSelection> extends QueryBase, ItemQuery {
+    type: 'evm'
+    fields?: F
+}
+
+export interface ItemQuery {
+    logs?: LogRequest[]
+    transactions?: TransactionRequest[]
+    traces?: TraceRequest[]
+    stateDiffs?: StateDiffRequest[]
+}
+
+export interface LogRequest {
+    address?: Bytes20[]
+    topic0?: Bytes32[]
+    topic1?: Bytes32[]
+    topic2?: Bytes32[]
+    topic3?: Bytes32[]
+    transaction?: boolean
+    transactionTraces?: boolean
+    transactionLogs?: boolean
+    transactionStateDiffs?: boolean
+}
+
+export interface TransactionRequest {
+    to?: Bytes20[]
+    from?: Bytes20[]
+    sighash?: Bytes8[]
+    type?: number[]
+    logs?: boolean
+    traces?: boolean
+    stateDiffs?: boolean
+}
+
+export interface TraceRequest {
+    type?: string[]
+    createFrom?: Bytes20[]
+    callTo?: Bytes20[]
+    callFrom?: Bytes20[]
+    callSighash?: Bytes[]
+    suicideRefundAddress?: Bytes[]
+    rewardAuthor?: Bytes20[]
+    transaction?: boolean
+    transactionLogs?: boolean
+    subtraces?: boolean
+    parents?: boolean
+}
+
+export interface StateDiffRequest {
+    address?: Bytes20[]
+    key?: Bytes[]
+    kind?: StateDiff['kind'][]
+    transaction?: boolean
+}

package/src/query/evm/schema.ts

@@ -0,0 +1,277 @@
+import {
+    array,
+    BYTES,
+    NAT,
+    object,
+    option,
+    QTY,
+    STRING,
+    STRING_FLOAT,
+    taggedUnion,
+    withDefault,
+} from '@subsquid/util-internal-validation'
+import {isEmpty, project} from '../util'
+import type {FieldSelection} from './fields'
+
+export function patchQueryFields(fields: FieldSelection): FieldSelection {
+    fields = {...fields}
+
+    let {number, hash, parentHash, ...block} = (fields.block as any) ?? {}
+    fields.block = {
+        ...block,
+        number: true,
+        hash: true,
+        parentHash: true,
+    }
+
+    let {type, ...trace} = (fields.trace as any) ?? {}
+    fields.trace = {
+        ...trace,
+        type: true,
+    }
+
+    let {kind, ...stateDiff} = (fields.stateDiff as any) ?? {}
+    fields.stateDiff = {
+        ...stateDiff,
+        kind: true,
+    }
+
+    return fields
+}
+
+export function getBlockSchema(fields: FieldSelection) {
+    return object({
+        header: getBlockHeaderSchema(fields.block),
+        transactions: withDefault([], array(getTransactionSchema(fields.transaction))),
+        logs: withDefault([], array(getLogSchema(fields.log))),
+        traces: withDefault([], array(getTraceFrameSchema(fields.trace))),
+        stateDiffs: withDefault([], array(getStateDiffSchema(fields.stateDiff))),
+    })
+}
+
+function getBlockHeaderSchema(fields: FieldSelection['block']) {
+    return object({
+        number: NAT,
+        hash: BYTES,
+        parentHash: BYTES,
+        ...project(fields, {
+            nonce: BYTES,
+            sha3Uncles: BYTES,
+            logsBloom: BYTES,
+            transactionsRoot: BYTES,
+            stateRoot: BYTES,
+            receiptsRoot: BYTES,
+            mixHash: BYTES,
+            miner: BYTES,
+            extraData: BYTES,
+            size: NAT,
+            gasLimit: QTY,
+            gasUsed: QTY,
+            timestamp: NAT,
+            difficulty: QTY,
+            totalDifficulty: option(QTY),
+            baseFeePerGas: option(QTY),
+            l1BlockNumber: option(NAT),
+        }),
+    })
+}
+
+const Authorization = object({
+    chainId: NAT,
+    nonce: NAT,
+    address: BYTES,
+    yParity: NAT,
+    r: BYTES,
+    s: BYTES,
+})
+
+function getTransactionSchema(fields: FieldSelection['transaction']) {
+    return object(
+        project(fields, {
+            transactionIndex: NAT,
+            hash: BYTES,
+            from: BYTES,
+            to: option(BYTES),
+            gas: QTY,
+            gasPrice: option(QTY),
+            maxFeePerGas: option(QTY),
+            maxPriorityFeePerGas: option(QTY),
+            input: BYTES,
+            sighash: withDefault('0x', BYTES),
+            nonce: NAT,
+            value: QTY,
+            v: option(QTY),
+            r: option(BYTES),
+            s: option(BYTES),
+            yParity: option(NAT),
+            chainId: option(NAT),
+            authorizationList: option(array(Authorization)),
+            gasUsed: QTY,
+            cumulativeGasUsed: QTY,
+            effectiveGasPrice: QTY,
+            contractAddress: option(BYTES),
+            type: option(NAT),
+            status: option(NAT),
+            l1Fee: option(QTY),
+            l1FeeScalar: option(STRING_FLOAT),
+            l1GasPrice: option(QTY),
+            l1GasUsed: option(QTY),
+            l1BlobBaseFee: option(QTY),
+            l1BlobBaseFeeScalar: option(NAT),
+            l1BaseFeeScalar: option(NAT),
+        })
+    )
+}
+
+function getLogSchema(fields: FieldSelection['log']) {
+    return object(
+        project(fields, {
+            logIndex: NAT,
+            transactionIndex: NAT,
+            transactionHash: BYTES,
+            address: BYTES,
+            data: BYTES,
+            topics: array(BYTES),
+        })
+    )
+}
+
+function getTraceFrameSchema(fields: FieldSelection['trace']) {
+    let traceBase = project(fields, {
+        transactionIndex: NAT,
+        traceAddress: array(NAT),
+        subtraces: NAT,
+        error: option(STRING),
+        revertReason: option(STRING),
+    })
+
+    let traceCreateAction = project(
+        {
+            from: fields?.createFrom,
+            value: fields?.createValue,
+            gas: fields?.createGas,
+            init: fields?.createInit,
+        },
+        {
+            from: BYTES,
+            value: QTY,
+            gas: QTY,
+            init: withDefault('0x', BYTES),
+        }
+    )
+
+    let traceCreateResult = project(
+        {
+            gasUsed: fields?.createResultGasUsed,
+            code: fields?.createResultCode,
+            address: fields?.createResultAddress,
+        },
+        {
+            gasUsed: QTY,
+            code: withDefault('0x', BYTES),
+            address: withDefault('0x0000000000000000000000000000000000000000', BYTES),
+        }
+    )
+
+    let TraceCreate = object({
+        ...traceBase,
+        action: isEmpty(traceCreateAction) ? undefined : object(traceCreateAction),
+        result: isEmpty(traceCreateResult) ? undefined : option(object(traceCreateResult)),
+    })
+
+    let traceCallAction = project(
+        {
+            callType: fields?.callCallType,
+            from: fields?.callFrom,
+            to: fields?.callTo,
+            value: fields?.callValue,
+            gas: fields?.callGas,
+            input: fields?.callInput,
+            sighash: fields?.callSighash,
+        },
+        {
+            callType: STRING,
+            from: BYTES,
+            to: BYTES,
+            value: option(QTY),
+            gas: QTY,
+            input: BYTES,
+            sighash: withDefault('0x', BYTES),
+        }
+    )
+
+    let traceCallResult = project(
+        {
+            gasUsed: fields?.callResultGasUsed,
+            output: fields?.callResultOutput,
+        },
+        {
+            gasUsed: QTY,
+            output: withDefault('0x', BYTES),
+        }
+    )
+
+    let TraceCall = object({
+        ...traceBase,
+        action: isEmpty(traceCallAction) ? undefined : object(traceCallAction),
+        result: isEmpty(traceCallResult) ? undefined : option(object(traceCallResult)),
+    })
+
+    let traceSuicideAction = project(
+        {
+            address: fields?.suicideAddress,
+            refundAddress: fields?.suicideRefundAddress,
+            balance: fields?.suicideBalance,
+        },
+        {
+            address: BYTES,
+            refundAddress: BYTES,
+            balance: QTY,
+        }
+    )
+
+    let TraceSuicide = object({
+        ...traceBase,
+        action: isEmpty(traceSuicideAction) ? undefined : object(traceSuicideAction),
+    })
+
+    let traceRewardAction = project(
+        {
+            author: fields?.rewardAuthor,
+            value: fields?.rewardValue,
+            type: fields?.rewardType,
+        },
+        {
+            author: BYTES,
+            value: QTY,
+            type: STRING,
+        }
+    )
+
+    let TraceReward = object({
+        ...traceBase,
+        action: isEmpty(traceRewardAction) ? undefined : object(traceRewardAction),
+    })
+
+    return taggedUnion('type', {
+        create: TraceCreate,
+        call: TraceCall,
+        suicide: TraceSuicide,
+        reward: TraceReward,
+    })
+}
+
+function getStateDiffSchema(fields: FieldSelection['stateDiff']) {
+    let stateDiffBase = {
+        transactionIndex: NAT,
+        address: BYTES,
+        key: STRING,
+    }
+
+    return taggedUnion('kind', {
+        ['=']: object(project(fields, stateDiffBase)),
+        ['+']: object(project(fields, {...stateDiffBase, next: BYTES})),
+        ['*']: object(project(fields, {...stateDiffBase, prev: BYTES, next: BYTES})),
+        ['-']: object(project(fields, {...stateDiffBase, prev: BYTES})),
+    })
+}