@subql/common-stellar 2.2.1-1

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@subql/common-stellar",
+  "version": "2.2.1-1",
+  "description": "",
+  "scripts": {
+    "build": "rm -rf dist && tsc -b",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "format": "prettier --write \"src/**/*.ts\""
+  },
+  "homepage": "https://github.com/subquery/subql-stellar",
+  "repository": "github:subquery/subql-stellar",
+  "author": "Ian He",
+  "main": "dist/index.js",
+  "license": "GPL-3.0",
+  "dependencies": {
+    "@subql/common": "^2.3.1-1",
+    "@subql/types-stellar": "2.2.3-3",
+    "js-yaml": "^4.1.0",
+    "pino": "^6.13.3",
+    "reflect-metadata": "^0.1.13"
+  },
+  "peerDependencies": {
+    "class-transformer": "*",
+    "class-validator": "*"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.4",
+    "@types/pino": "^6.3.12"
+  },
+  "stableVersion": "2.2.1-0"
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+export * from './project';

package/src/project/index.ts

@@ -0,0 +1,8 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+export * from './load';
+export * from './models';
+export * from './types';
+export * from './utils';
+export * from './versioned';

package/src/project/load.ts

@@ -0,0 +1,33 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import fs from 'fs';
+import path from 'path';
+import {loadFromJsonOrYaml} from '@subql/common';
+import {StellarProjectManifestVersioned, VersionedProjectManifest} from './versioned';
+
+export function parseStellarProjectManifest(raw: unknown): StellarProjectManifestVersioned {
+  const projectManifest = new StellarProjectManifestVersioned(raw as VersionedProjectManifest);
+  projectManifest.validate();
+  return projectManifest;
+}
+
+export function loadStellarProjectManifest(file: string): StellarProjectManifestVersioned {
+  let manifestPath = file;
+  if (fs.existsSync(file) && fs.lstatSync(file).isDirectory()) {
+    const yamlFilePath = path.join(file, 'project.yaml');
+    const jsonFilePath = path.join(file, 'project.json');
+    if (fs.existsSync(yamlFilePath)) {
+      manifestPath = yamlFilePath;
+    } else if (fs.existsSync(jsonFilePath)) {
+      manifestPath = jsonFilePath;
+    } else {
+      throw new Error(`Could not find project manifest under dir ${file}`);
+    }
+  }
+
+  const doc = loadFromJsonOrYaml(manifestPath);
+  const projectManifest = new StellarProjectManifestVersioned(doc as VersionedProjectManifest);
+  projectManifest.validate();
+  return projectManifest;
+}

package/src/project/models.ts

@@ -0,0 +1,135 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import {forbidNonWhitelisted} from '@subql/common';
+import {
+  StellarHandlerKind,
+  StellarDatasourceKind,
+  StellarEventFilter,
+  SubqlCustomHandler,
+  SubqlMapping,
+  SubqlHandler,
+  SubqlRuntimeHandler,
+  SubqlRuntimeDatasource,
+  SubqlCustomDatasource,
+  FileReference,
+  CustomDataSourceAsset,
+  SubqlEventHandler,
+} from '@subql/types-stellar';
+import {plainToClass, Transform, Type} from 'class-transformer';
+import {IsArray, IsEnum, IsInt, IsOptional, IsString, IsObject, ValidateNested} from 'class-validator';
+import {SubqlStellarProcessorOptions} from './types';
+
+export class EventFilter implements StellarEventFilter {
+  @IsOptional()
+  @IsString()
+  contractId?: string;
+  @IsOptional()
+  @IsArray()
+  topics?: string[];
+}
+
+export class EventHandler implements SubqlEventHandler {
+  @forbidNonWhitelisted({topics: '', contractId: ''})
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => EventFilter)
+  filter?: StellarEventFilter;
+  @IsEnum(StellarHandlerKind, {groups: [StellarHandlerKind.Event]})
+  kind: StellarHandlerKind.Event;
+  @IsString()
+  handler: string;
+}
+
+export class CustomHandler implements SubqlCustomHandler {
+  @IsString()
+  kind: string;
+  @IsString()
+  handler: string;
+  @IsObject()
+  @IsOptional()
+  filter?: Record<string, unknown>;
+}
+
+export class StellarMapping implements SubqlMapping {
+  @Transform((params) => {
+    const handlers: SubqlHandler[] = params.value;
+    return handlers.map((handler) => {
+      switch (handler.kind) {
+        case StellarHandlerKind.Event:
+          return plainToClass(EventHandler, handler);
+        default:
+          throw new Error(`handler ${(handler as any).kind} not supported`);
+      }
+    });
+  })
+  @IsArray()
+  @ValidateNested()
+  handlers: SubqlHandler[];
+  @IsString()
+  file: string;
+}
+
+export class CustomMapping implements SubqlMapping<SubqlCustomHandler> {
+  @IsArray()
+  @Type(() => CustomHandler)
+  @ValidateNested()
+  handlers: CustomHandler[];
+  @IsString()
+  file: string;
+}
+
+export class StellarProcessorOptions implements SubqlStellarProcessorOptions {
+  @IsOptional()
+  @IsString()
+  abi?: string;
+  @IsOptional()
+  @IsString()
+  address?: string;
+}
+
+export class RuntimeDataSourceBase<M extends SubqlMapping<SubqlRuntimeHandler>> implements SubqlRuntimeDatasource<M> {
+  @IsEnum(StellarDatasourceKind, {
+    groups: [StellarDatasourceKind.Runtime],
+  })
+  kind: StellarDatasourceKind.Runtime;
+  @Type(() => StellarMapping)
+  @ValidateNested()
+  mapping: M;
+  @IsOptional()
+  @IsInt()
+  startBlock?: number;
+  @IsOptional()
+  assets?: Map<string, FileReference>;
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => StellarProcessorOptions)
+  options?: StellarProcessorOptions;
+}
+
+export class FileReferenceImpl implements FileReference {
+  @IsString()
+  file: string;
+}
+
+export class CustomDataSourceBase<K extends string, M extends SubqlMapping = SubqlMapping<SubqlCustomHandler>>
+  implements SubqlCustomDatasource<K, M>
+{
+  @IsString()
+  kind: K;
+  @Type(() => CustomMapping)
+  @ValidateNested()
+  mapping: M;
+  @IsOptional()
+  @IsInt()
+  startBlock?: number;
+  @Type(() => FileReferenceImpl)
+  @ValidateNested({each: true})
+  assets: Map<string, CustomDataSourceAsset>;
+  @Type(() => FileReferenceImpl)
+  @IsObject()
+  processor: FileReference;
+  @IsOptional()
+  @ValidateNested()
+  options?: StellarProcessorOptions;
+}

package/src/project/project.spec.ts

@@ -0,0 +1,83 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import path from 'path';
+import {RunnerQueryBaseModel} from '@subql/common';
+import {validateSync} from 'class-validator';
+import {DeploymentV1_0_0, StellarRunnerNodeImpl, StellarRunnerSpecsImpl} from '../project/versioned/v1_0_0';
+import {loadStellarProjectManifest} from './load';
+
+const projectsDir = path.join(__dirname, '../../test');
+
+describe('project.yaml', () => {
+  it('can validate project.yaml', () => {
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_falsy.yaml'))).toThrow();
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_falsy_array.yaml'))).toThrow();
+  });
+
+  it('can fail validation if version not supported', () => {
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_invalid_version.yaml'))).toThrow();
+  });
+
+  it('can validate a v1.0.0 project.yaml with templates', () => {
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_1.0.0.yaml'))).not.toThrow();
+  });
+
+  it('get v1.0.0 deployment mapping filter', () => {
+    const manifestVersioned = loadStellarProjectManifest(path.join(projectsDir, 'project_1.0.0.yaml'));
+
+    const deployment = manifestVersioned.asV1_0_0.deployment;
+    const filter = deployment.dataSources[0].mapping.handlers[0].filter;
+    const deploymentString = manifestVersioned.toDeployment();
+    expect(filter).not.toBeNull();
+    expect(deploymentString).toContain('COUNTER');
+  });
+
+  it('can convert genesis hash in v1.0.0 to chainId in deployment', () => {
+    const deployment = loadStellarProjectManifest(path.join(projectsDir, 'project_1.0.0.yaml')).asV1_0_0.deployment;
+    expect(deployment.network.chainId).not.toBeNull();
+    console.log(deployment.network.chainId);
+  });
+
+  it.skip('can get chainId for deployment', () => {
+    const deployment = loadStellarProjectManifest(path.join(projectsDir, 'project_1.0.0_chainId.yaml')).asV1_0_0
+      .deployment;
+    expect(deployment.network.chainId).toBe('moonbeamChainId');
+  });
+
+  it('can validate deployment runner versions', () => {
+    const deployment = new DeploymentV1_0_0();
+    const nodeImp = new StellarRunnerNodeImpl();
+    const queryImp = new RunnerQueryBaseModel();
+    deployment.specVersion = '1.0.0';
+    deployment.runner = new StellarRunnerSpecsImpl();
+
+    nodeImp.name = '@subql/node-stellar';
+    nodeImp.version = '0.29.1';
+    deployment.runner.node = nodeImp;
+
+    queryImp.name = '@subql/query';
+    queryImp.version = '0.213.1';
+
+    deployment.runner.query = queryImp;
+
+    validateSync(deployment.runner, {whitelist: true, forbidNonWhitelisted: true});
+  });
+
+  it('can validate a v1.0.0 project.yaml with unsupported runner node', () => {
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_1.0.0_bad_runner.yaml'))).toThrow();
+  });
+
+  //TODO, pre-release should be excluded
+  it.skip('can throw error with unsupported runner version', () => {
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_1.0.0_bad_runner_version.yaml'))).toThrow();
+  });
+
+  it('can validate a v1.0.0 project.yaml runner and datasource mismatches', () => {
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_1.0.0_runner_ds_mismatch.yaml'))).toThrow();
+  });
+
+  it('can fail validation if custom ds missing processor', () => {
+    expect(() => loadStellarProjectManifest(path.join(projectsDir, 'project_0.2.0_invalid_custom_ds.yaml'))).toThrow();
+  });
+});

package/src/project/types.ts

@@ -0,0 +1,28 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import {IProjectManifest, ProjectNetworkConfig} from '@subql/common';
+import {SubqlDatasource} from '@subql/types-stellar';
+
+// All of these used to be redefined in this file, re-exporting for simplicity
+export {
+  SubqlStellarProcessorOptions,
+  SubqlRuntimeHandler,
+  SubqlCustomHandler,
+  SubqlHandler,
+  StellarHandlerKind,
+  SubqlDatasource as SubqlStellarDataSource,
+  SubqlCustomDatasource as SubqlStellarCustomDataSource,
+  StellarEventFilter,
+  SubqlDatasourceProcessor,
+  SubqlHandlerFilter,
+  StellarDatasourceKind,
+  StellarRuntimeHandlerInputMap as StellarRuntimeHandlerInputMap,
+} from '@subql/types-stellar';
+
+export type IStellarProjectManifest = IProjectManifest<SubqlDatasource>;
+
+export interface StellarProjectNetworkConfig extends ProjectNetworkConfig {
+  genesisHash?: string;
+  chainId?: string;
+}

package/src/project/utils.ts

@@ -0,0 +1,25 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import {
+  SecondLayerHandlerProcessor,
+  SubqlCustomDatasource,
+  SubqlDatasource,
+  StellarDatasourceKind,
+  StellarHandlerKind,
+  SubqlRuntimeDatasource,
+} from '@subql/types-stellar';
+
+export function isEventHandlerProcessor<E>(
+  hp: SecondLayerHandlerProcessor<StellarHandlerKind, unknown, unknown>
+): hp is SecondLayerHandlerProcessor<StellarHandlerKind.Event, unknown, E> {
+  return hp.baseHandlerKind === StellarHandlerKind.Event;
+}
+
+export function isCustomDs(ds: SubqlDatasource): ds is SubqlCustomDatasource<string> {
+  return ds.kind !== StellarDatasourceKind.Runtime && !!(ds as SubqlCustomDatasource<string>).processor;
+}
+
+export function isRuntimeDs(ds: SubqlDatasource): ds is SubqlRuntimeDatasource {
+  return ds.kind === StellarDatasourceKind.Runtime;
+}

package/src/project/versioned/ProjectManifestVersioned.ts

@@ -0,0 +1,71 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import {plainToClass} from 'class-transformer';
+import {IStellarProjectManifest, SubqlStellarDataSource} from '../types';
+import {ProjectManifestV1_0_0Impl} from './v1_0_0';
+export type VersionedProjectManifest = {specVersion: string};
+
+const SOROBAN_SUPPORTED_VERSIONS = {
+  '1.0.0': ProjectManifestV1_0_0Impl,
+};
+
+type Versions = keyof typeof SOROBAN_SUPPORTED_VERSIONS;
+
+type ProjectManifestImpls = InstanceType<(typeof SOROBAN_SUPPORTED_VERSIONS)[Versions]>;
+
+export function manifestIsV1_0_0(manifest: IStellarProjectManifest): manifest is ProjectManifestV1_0_0Impl {
+  return manifest.specVersion === '1.0.0';
+}
+
+export class StellarProjectManifestVersioned implements IStellarProjectManifest {
+  private _impl: ProjectManifestImpls;
+
+  constructor(projectManifest: VersionedProjectManifest) {
+    const klass = SOROBAN_SUPPORTED_VERSIONS[projectManifest.specVersion as Versions];
+    if (!klass) {
+      throw new Error('specVersion not supported for project manifest file');
+    }
+    this._impl = plainToClass<ProjectManifestImpls, VersionedProjectManifest>(klass, projectManifest);
+  }
+
+  get asImpl(): ProjectManifestImpls {
+    return this._impl;
+  }
+
+  get isV1_0_0(): boolean {
+    return this.specVersion === '1.0.0';
+  }
+
+  get asV1_0_0(): ProjectManifestV1_0_0Impl {
+    return this._impl as ProjectManifestV1_0_0Impl;
+  }
+
+  toDeployment(): string | undefined {
+    return this._impl.toDeployment();
+  }
+
+  validate(): void {
+    return this._impl.validate();
+  }
+
+  get dataSources(): SubqlStellarDataSource[] {
+    return this._impl.dataSources;
+  }
+
+  get schema(): string {
+    return this._impl.schema.file;
+  }
+
+  get specVersion(): string {
+    return this._impl.specVersion;
+  }
+
+  get description(): string {
+    return this._impl.description;
+  }
+
+  get repository(): string {
+    return this._impl.repository;
+  }
+}

package/src/project/versioned/index.ts

@@ -0,0 +1,5 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+export * from './ProjectManifestVersioned';
+export * from './v1_0_0';

package/src/project/versioned/v1_0_0/index.ts

@@ -0,0 +1,5 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+export * from './model';
+export * from './types';

package/src/project/versioned/v1_0_0/model.ts

@@ -0,0 +1,202 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import {
+  BaseMapping,
+  FileType,
+  NodeSpec,
+  ProjectManifestBaseImpl,
+  QuerySpec,
+  RunnerNodeImpl,
+  RunnerQueryBaseModel,
+  RunnerSpecs,
+  validateObject,
+} from '@subql/common';
+import {SubqlCustomDatasource, SubqlMapping, SubqlRuntimeDatasource} from '@subql/types-stellar';
+import {plainToClass, Transform, TransformFnParams, Type} from 'class-transformer';
+import {
+  Equals,
+  IsArray,
+  IsIn,
+  IsNotEmpty,
+  IsObject,
+  IsOptional,
+  IsString,
+  ValidateNested,
+  validateSync,
+} from 'class-validator';
+import {CustomDataSourceBase, StellarMapping, RuntimeDataSourceBase} from '../../models';
+import {SubqlStellarDataSource, SubqlRuntimeHandler} from '../../types';
+import {CustomDatasourceTemplate, StellarProjectManifestV1_0_0, RuntimeDatasourceTemplate} from './types';
+
+const Stellar_NODE_NAME = `@subql/node-stellar`;
+
+export class StellarProjectMapping extends StellarMapping {
+  @IsString()
+  file: string;
+}
+
+export class StellarRunnerNodeImpl extends RunnerNodeImpl {
+  @IsIn([Stellar_NODE_NAME], {
+    message: `Runner Substrate node name incorrect, suppose be '${Stellar_NODE_NAME}'`,
+  })
+  name: string;
+}
+
+export class StellarRuntimeDataSourceImpl
+  extends RuntimeDataSourceBase<SubqlMapping<SubqlRuntimeHandler>>
+  implements SubqlRuntimeDatasource
+{
+  validate(): void {
+    return validateObject(this, 'failed to validate runtime datasource.');
+  }
+}
+
+export class StellarCustomDataSourceImpl<
+    K extends string = string,
+    M extends BaseMapping<any, any> = BaseMapping<Record<string, unknown>, any>
+  >
+  extends CustomDataSourceBase<K, M>
+  implements SubqlCustomDatasource<K, M>
+{
+  validate(): void {
+    return validateObject(this, 'failed to validate custom datasource.');
+  }
+}
+
+export class RuntimeDatasourceTemplateImpl extends StellarRuntimeDataSourceImpl implements RuntimeDatasourceTemplate {
+  @IsString()
+  name: string;
+}
+
+export class CustomDatasourceTemplateImpl extends StellarCustomDataSourceImpl implements CustomDatasourceTemplate {
+  @IsString()
+  name: string;
+}
+
+export class StellarRunnerSpecsImpl implements RunnerSpecs {
+  @IsObject()
+  @ValidateNested()
+  @Type(() => StellarRunnerNodeImpl)
+  node: NodeSpec;
+  @IsObject()
+  @ValidateNested()
+  @Type(() => RunnerQueryBaseModel)
+  query: QuerySpec;
+}
+
+export class ProjectNetworkDeploymentV1_0_0 {
+  @IsNotEmpty()
+  @Transform(({value}: TransformFnParams) => value.trim())
+  @IsString()
+  chainId: string;
+  @ValidateNested()
+  @Type(() => FileType)
+  @IsOptional()
+  chaintypes?: FileType;
+  @IsOptional()
+  @IsArray()
+  bypassBlocks?: (number | string)[];
+}
+
+export class ProjectNetworkV1_0_0 extends ProjectNetworkDeploymentV1_0_0 {
+  @IsString({each: true})
+  @IsOptional()
+  endpoint?: string | string[];
+  @IsString()
+  @IsOptional()
+  dictionary?: string;
+}
+
+export class DeploymentV1_0_0 {
+  @Transform((params) => {
+    if (params.value.genesisHash && !params.value.chainId) {
+      params.value.chainId = params.value.genesisHash;
+    }
+    return plainToClass(ProjectNetworkDeploymentV1_0_0, params.value);
+  })
+  @ValidateNested()
+  @Type(() => ProjectNetworkDeploymentV1_0_0)
+  network: ProjectNetworkDeploymentV1_0_0;
+  @Equals('1.0.0')
+  @IsString()
+  specVersion: string;
+  @IsObject()
+  @ValidateNested()
+  @Type(() => StellarRunnerSpecsImpl)
+  runner: RunnerSpecs;
+  @ValidateNested()
+  @Type(() => FileType)
+  schema: FileType;
+  @IsArray()
+  @ValidateNested()
+  @Type(() => StellarCustomDataSourceImpl, {
+    discriminator: {
+      property: 'kind',
+      subTypes: [{value: StellarRuntimeDataSourceImpl, name: 'stellar/Runtime'}],
+    },
+    keepDiscriminatorProperty: true,
+  })
+  dataSources: (SubqlRuntimeDatasource | SubqlCustomDatasource)[];
+  @IsOptional()
+  @IsArray()
+  @ValidateNested()
+  @Type(() => CustomDatasourceTemplateImpl, {
+    discriminator: {
+      property: 'kind',
+      subTypes: [{value: RuntimeDatasourceTemplateImpl, name: 'stellar/Runtime'}],
+    },
+    keepDiscriminatorProperty: true,
+  })
+  templates?: (RuntimeDatasourceTemplate | CustomDatasourceTemplate)[];
+}
+
+export class ProjectManifestV1_0_0Impl<D extends object = DeploymentV1_0_0>
+  extends ProjectManifestBaseImpl<D>
+  implements StellarProjectManifestV1_0_0
+{
+  @Equals('1.0.0')
+  specVersion: string;
+  @Type(() => StellarCustomDataSourceImpl, {
+    discriminator: {
+      property: 'kind',
+      subTypes: [{value: StellarRuntimeDataSourceImpl, name: 'stellar/Runtime'}],
+    },
+    keepDiscriminatorProperty: true,
+  })
+  dataSources: SubqlStellarDataSource[];
+  @Type(() => ProjectNetworkV1_0_0)
+  network: ProjectNetworkV1_0_0;
+  @IsString()
+  name: string;
+  @IsString()
+  version: string;
+  @ValidateNested()
+  @Type(() => FileType)
+  schema: FileType;
+  @IsOptional()
+  @IsArray()
+  @ValidateNested()
+  @Type(() => CustomDatasourceTemplateImpl, {
+    discriminator: {
+      property: 'kind',
+      subTypes: [{value: RuntimeDatasourceTemplateImpl, name: 'stellar/Runtime'}],
+    },
+    keepDiscriminatorProperty: true,
+  })
+  templates?: (RuntimeDatasourceTemplate | CustomDatasourceTemplate)[];
+  @IsObject()
+  @ValidateNested()
+  @Type(() => StellarRunnerSpecsImpl)
+  runner: RunnerSpecs;
+  protected _deployment: D;
+
+  get deployment(): D {
+    if (!this._deployment) {
+      this._deployment = plainToClass(DeploymentV1_0_0, this) as unknown as D;
+      //validateSync(this._deployment.)
+      validateSync(this._deployment, {whitelist: true});
+    }
+    return this._deployment;
+  }
+}

package/src/project/versioned/v1_0_0/types.ts

@@ -0,0 +1,13 @@
+// Copyright 2020-2023 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import {ProjectManifestV1_0_0, TemplateBase} from '@subql/common';
+import {SubqlCustomDatasource, SubqlRuntimeDatasource} from '@subql/types-stellar';
+
+export interface RuntimeDatasourceTemplate extends Omit<SubqlRuntimeDatasource, 'name'>, TemplateBase {}
+export interface CustomDatasourceTemplate extends Omit<SubqlCustomDatasource, 'name'>, TemplateBase {}
+
+export type StellarProjectManifestV1_0_0 = ProjectManifestV1_0_0<
+  RuntimeDatasourceTemplate | CustomDatasourceTemplate,
+  SubqlRuntimeDatasource | SubqlCustomDatasource
+>;

package/test/project_1.0.0.yaml

@@ -0,0 +1,34 @@
+specVersion: '1.0.0'
+
+name: 'stellar-subql-starter'
+version: '0.0.1'
+runner:
+  node:
+    name: '@subql/node-stellar'
+    version: '*'
+  query:
+    name: '@subql/query'
+    version: '*'
+description: 'This project can be use as a starting point for developing your new Stellar SubQuery project'
+repository: 'https://github.com/subquery/stellar-subql-starter'
+
+schema:
+  file: './schema.graphql'
+
+network:
+  chainId: 'Test SDF Future Network ; October 2022'
+  endpoint: ['https://rpc-futurenet.stellar.org:443']
+
+dataSources:
+  - kind: stellar/Runtime
+    startBlock: 52400
+    mapping:
+      file: './dist/index.js'
+      handlers:
+        - handler: handleEvent
+          kind: stellar/EventHandler
+          filter:
+            contractId: '34799b3411940249e73d21def8eb2c2b56b285ab8d1ca76d6780ec10a0e8f02e'
+            topics:
+              - 'COUNTER'
+              - 'increment'