fixup: types-cosmos

Author: bryanchriswhite

docker/types-cosmos/dist/.tsbuildinfo

@@ -0,0 +1,12 @@
+import type { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import type { Registry } from '@cosmjs/proto-signing';
+import type Pino from 'pino';
+import { Store, DynamicDatasourceCreator } from './interfaces';
+declare global {
+    const apiUnsafe: CosmWasmClient;
+    const api: CosmWasmClient;
+    const logger: Pino.Logger;
+    const store: Store;
+    const createDynamicDatasource: DynamicDatasourceCreator;
+    const registry: Registry;
+}

docker/types-cosmos/dist/global.d.ts

@@ -0,0 +1,2 @@
+export * from './interfaces';
+export * from './project';

docker/types-cosmos/dist/global.js

@@ -0,0 +1,47 @@
+import { DecodedTxRaw } from '@cosmjs/proto-signing';
+import { Block } from '@cosmjs/stargate';
+import { Event, Log } from '@cosmjs/stargate/build/logs';
+import { TxData } from '@cosmjs/tendermint-rpc';
+export interface Entity {
+    id: string;
+}
+export declare type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+export interface Store {
+    get(entity: string, id: string): Promise<Entity | null>;
+    getByField(entity: string, field: string, value: any): Promise<Entity[]>;
+    getOneByField(entity: string, field: string, value: any): Promise<Entity | null>;
+    set(entity: string, id: string, data: Entity): Promise<void>;
+    bulkCreate(entity: string, data: Entity[]): Promise<void>;
+    remove(entity: string, id: string): Promise<void>;
+}
+export interface CosmosBlock {
+    block: Block;
+    txs: TxData[];
+}
+export interface CosmosTransaction {
+    idx: number;
+    block: CosmosBlock;
+    hash: string;
+    tx: TxData;
+    decodedTx: DecodedTxRaw;
+}
+export interface CosmosMessage<T = any> {
+    idx: number;
+    block: CosmosBlock;
+    tx: CosmosTransaction;
+    msg: {
+        typeUrl: string;
+        decodedMsg: T;
+    };
+}
+export interface CosmosEvent {
+    idx: number;
+    block: CosmosBlock;
+    tx: CosmosTransaction;
+    msg: CosmosMessage;
+    log: Log;
+    event: Event;
+}
+export declare type DynamicDatasourceCreator = (name: string, args: Record<string, unknown>) => Promise<void>;

docker/types-cosmos/dist/global.js.map

@@ -0,0 +1,160 @@
+import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import { CosmosBlock, CosmosTransaction, CosmosMessage, CosmosEvent } from './interfaces';
+export interface FileReference {
+    file: string;
+}
+export interface CustomModule {
+    file: string;
+    messages: string[];
+}
+export declare type CustomDataSourceAsset = FileReference;
+export declare type Processor<O = any> = FileReference & {
+    options?: O;
+};
+export declare enum SubqlCosmosDatasourceKind {
+    Runtime = "cosmos/Runtime",
+    Custom = "cosmos/Custom"
+}
+export declare enum SubqlCosmosHandlerKind {
+    Block = "cosmos/BlockHandler",
+    Transaction = "cosmos/TransactionHandler",
+    Message = "cosmos/MessageHandler",
+    Event = "cosmos/EventHandler"
+}
+export declare type CosmosRuntimeHandlerInputMap = {
+    [SubqlCosmosHandlerKind.Block]: CosmosBlock;
+    [SubqlCosmosHandlerKind.Transaction]: CosmosTransaction;
+    [SubqlCosmosHandlerKind.Message]: CosmosMessage;
+    [SubqlCosmosHandlerKind.Event]: CosmosEvent;
+};
+declare type CosmosRuntimeFilterMap = {
+    [SubqlCosmosHandlerKind.Block]: {};
+    [SubqlCosmosHandlerKind.Transaction]: {};
+    [SubqlCosmosHandlerKind.Message]: SubqlCosmosMessageFilter;
+    [SubqlCosmosHandlerKind.Event]: SubqlCosmosEventFilter;
+};
+export interface CosmosProjectManifest {
+    specVersion: string;
+    description: string;
+    repository: string;
+    schema: {
+        file: string;
+    };
+    network: CosmosNetwork;
+    dataSources: SubqlCosmosDatasource[];
+}
+export interface CosmosNetwork {
+    genesisHash: string;
+    endpoint: string;
+    chainId: string;
+    chainTypes?: Map<string, CustomModule>;
+}
+export interface SubqlCosmosMessageFilter {
+    type: string;
+    contractCall?: string;
+    values?: {
+        [key: string]: string;
+    };
+}
+export interface SubqlCosmosEventFilter {
+    type: string;
+    messageFilter?: SubqlCosmosMessageFilter;
+}
+export declare type SubqlCosmosHandlerFilter = SubqlCosmosEventFilter | SubqlCosmosMessageFilter;
+export interface SubqlCosmosBlockHandler {
+    handler: string;
+    kind: SubqlCosmosHandlerKind.Block;
+    filter?: undefined;
+}
+export interface SubqlCosmosTransactionHandler {
+    handler: string;
+    kind: SubqlCosmosHandlerKind.Transaction;
+    filter?: undefined;
+}
+export interface SubqlCosmosMessageHandler {
+    handler: string;
+    kind: SubqlCosmosHandlerKind.Message;
+    filter?: SubqlCosmosMessageFilter;
+}
+export interface SubqlCosmosEventHandler {
+    handler: string;
+    kind: SubqlCosmosHandlerKind.Event;
+    filter?: SubqlCosmosEventFilter;
+}
+export interface SubqlCosmosCustomHandler<K extends string = string, F = Record<string, unknown>> {
+    handler: string;
+    kind: K;
+    filter?: F;
+}
+export declare type SubqlCosmosRuntimeHandler = SubqlCosmosBlockHandler | SubqlCosmosTransactionHandler | SubqlCosmosMessageHandler | SubqlCosmosEventHandler;
+export declare type SubqlCosmosHandler = SubqlCosmosRuntimeHandler | SubqlCosmosCustomHandler;
+export interface SubqlCosmosMapping<T extends SubqlCosmosHandler = SubqlCosmosHandler> {
+    file: string;
+    handlers: T[];
+}
+interface ISubqlCosmosDatasource<M extends SubqlCosmosMapping> {
+    name?: string;
+    kind: string;
+    startBlock?: number;
+    mapping: M;
+}
+export interface SubqlCosmosRuntimeDatasource<M extends SubqlCosmosMapping<SubqlCosmosRuntimeHandler> = SubqlCosmosMapping<SubqlCosmosRuntimeHandler>> extends ISubqlCosmosDatasource<M> {
+    kind: SubqlCosmosDatasourceKind.Runtime;
+}
+export declare type SubqlCosmosDatasource = SubqlCosmosRuntimeDatasource | SubqlCosmosCustomDatasource;
+export declare type CustomCosmosDataSourceAsset = FileReference;
+export interface SubqlCosmosCustomDatasource<K extends string = string, M extends SubqlCosmosMapping = SubqlCosmosMapping<SubqlCosmosCustomHandler>, O = any> extends ISubqlCosmosDatasource<M> {
+    kind: K;
+    assets: Map<string, CustomCosmosDataSourceAsset>;
+    processor?: Processor<O>;
+}
+export interface HandlerInputTransformer_0_0_0<T extends SubqlCosmosHandlerKind, E, DS extends SubqlCosmosCustomDatasource = SubqlCosmosCustomDatasource> {
+    (input: CosmosRuntimeHandlerInputMap[T], ds: DS, api: CosmWasmClient, assets?: Record<string, string>): Promise<E>;
+}
+export interface HandlerInputTransformer_1_0_0<T extends SubqlCosmosHandlerKind, F, E, DS extends SubqlCosmosCustomDatasource = SubqlCosmosCustomDatasource> {
+    (params: {
+        input: CosmosRuntimeHandlerInputMap[T];
+        ds: DS;
+        filter?: F;
+        api: CosmWasmClient;
+        assets?: Record<string, string>;
+    }): Promise<E[]>;
+}
+export declare type SecondLayerHandlerProcessorArray<K extends string, F, T, DS extends SubqlCosmosCustomDatasource<K> = SubqlCosmosCustomDatasource<K>> = SecondLayerHandlerProcessor<SubqlCosmosHandlerKind.Block, F, T, DS> | SecondLayerHandlerProcessor<SubqlCosmosHandlerKind.Transaction, F, T, DS> | SecondLayerHandlerProcessor<SubqlCosmosHandlerKind.Message, F, T, DS> | SecondLayerHandlerProcessor<SubqlCosmosHandlerKind.Event, F, T, DS>;
+export interface SubqlCosmosDatasourceProcessor<K extends string, F, DS extends SubqlCosmosCustomDatasource<K> = SubqlCosmosCustomDatasource<K>, P extends Record<string, SecondLayerHandlerProcessorArray<K, F, any, DS>> = Record<string, SecondLayerHandlerProcessorArray<K, F, any, DS>>> {
+    kind: K;
+    validate(ds: DS, assets: Record<string, string>): void;
+    dsFilterProcessor(ds: DS, api: CosmWasmClient): boolean;
+    handlerProcessors: P;
+}
+export interface DictionaryQueryCondition {
+    field: string;
+    value: string | Record<string, string> | Array<Record<string, string>>;
+    matcher?: string;
+}
+export interface DictionaryQueryEntry {
+    entity: string;
+    conditions: DictionaryQueryCondition[];
+}
+interface SecondLayerHandlerProcessorBase<K extends SubqlCosmosHandlerKind, F, DS extends SubqlCosmosCustomDatasource = SubqlCosmosCustomDatasource> {
+    baseHandlerKind: K;
+    baseFilter: CosmosRuntimeFilterMap[K] | CosmosRuntimeFilterMap[K][];
+    filterValidator: (filter?: F) => void;
+    dictionaryQuery?: (filter: F, ds: DS) => DictionaryQueryEntry | undefined;
+}
+export interface SecondLayerHandlerProcessor_0_0_0<K extends SubqlCosmosHandlerKind, F, E, DS extends SubqlCosmosCustomDatasource = SubqlCosmosCustomDatasource> extends SecondLayerHandlerProcessorBase<K, F, DS> {
+    specVersion: undefined;
+    transformer: HandlerInputTransformer_0_0_0<K, E, DS>;
+    filterProcessor: (filter: F | undefined, input: CosmosRuntimeHandlerInputMap[K], ds: DS) => boolean;
+}
+export interface SecondLayerHandlerProcessor_1_0_0<K extends SubqlCosmosHandlerKind, F, E, DS extends SubqlCosmosCustomDatasource = SubqlCosmosCustomDatasource> extends SecondLayerHandlerProcessorBase<K, F, DS> {
+    specVersion: '1.0.0';
+    transformer: HandlerInputTransformer_1_0_0<K, F, E, DS>;
+    filterProcessor: (params: {
+        filter: F | undefined;
+        input: CosmosRuntimeHandlerInputMap[K];
+        ds: DS;
+    }) => boolean;
+}
+export declare type SecondLayerHandlerProcessor<K extends SubqlCosmosHandlerKind, F, E, DS extends SubqlCosmosCustomDatasource = SubqlCosmosCustomDatasource> = SecondLayerHandlerProcessor_0_0_0<K, F, E, DS> | SecondLayerHandlerProcessor_1_0_0<K, F, E, DS>;
+export {};