@graphprotocol/graph-cli 0.37.3-alpha-20230112195908-6a078ea → 0.37.3-alpha-20230112205341-caa8660

package/CHANGELOG.md

@@ -1,11 +1,12 @@
 # @graphprotocol/graph-cli
 
-## 0.37.3-alpha-20230112195908-6a078ea
+## 0.37.3-alpha-20230112205341-caa8660
 
 ### Patch Changes
 
 - [#1020](https://github.com/graphprotocol/graph-cli/pull/1020) [`6184688`](https://github.com/graphprotocol/graph-cli/commit/6184688d7e6efaae49a722410befd28da0af87b0) Thanks [@saihaj](https://github.com/saihaj)! - dependencies updates:
   - Updated dependency [`immutable@4.2.1` ↗︎](https://www.npmjs.com/package/immutable/v/4.2.1) (from `3.8.2`, in `dependencies`)
+  - Removed dependency [`dockerode@2.5.8` ↗︎](https://www.npmjs.com/package/dockerode/v/2.5.8) (from `dependencies`)
 
 ## 0.37.2
 

package/dist/command-helpers/studio.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateStudioNetwork = exports.allowedStudioNetworks = void 0;
-const allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli', 'gnosis'];
-exports.allowedStudioNetworks = allowedStudioNetworks;
-const validateStudioNetwork = ({ studio, product, network }) => {
+exports.allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli', 'gnosis'];
+const validateStudioNetwork = ({ studio, product, network, }) => {
     let isStudio = studio || product === 'subgraph-studio';
-    let isAllowedNetwork = allowedStudioNetworks.includes(network);
+    let isAllowedNetwork = exports.allowedStudioNetworks.includes(
+    // @ts-expect-error we're checking if the network is allowed
+    network);
     if (isStudio && !isAllowedNetwork) {
-        throw new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`);
+        throw new Error(`The Subgraph Studio only allows subgraphs for these networks: ${exports.allowedStudioNetworks.join(', ')}`);
     }
 };
 exports.validateStudioNetwork = validateStudioNetwork;

package/dist/command-helpers/studio.test.js

@@ -19,7 +19,6 @@ describe('Version Command Helpers', () => {
             test("And it's NOT an allowed network", () => {
                 expect(() => (0, studio_1.validateStudioNetwork)({
                     product: 'subgraph-studio',
-                    // @ts-expect-error for tests sake
                     network: 'celo',
                 })).toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${studio_1.allowedStudioNetworks.join(', ')}`));
             });
@@ -33,9 +32,7 @@ describe('Version Command Helpers', () => {
             });
             test("And it's NOT an allowed network", () => {
                 expect(() => (0, studio_1.validateStudioNetwork)({
-                    // @ts-expect-error for tests sake
                     product: 'hosted-service',
-                    // @ts-expect-error for tests sake
                     network: 'celo',
                 })).not.toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${studio_1.allowedStudioNetworks.join(', ')}`));
             });

package/dist/commands/init.js

@@ -29,9 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chalk_1 = __importDefault(require("chalk"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const toolbox = __importStar(require("gluegun/toolbox"));
 const fs_1 = __importDefault(require("fs"));
-const cli_1 = __importDefault(require("../cli"));
+const graphCli = __importStar(require("../cli"));
 const subgraph_1 = require("../command-helpers/subgraph");
 const DataSourcesExtractor = __importStar(require("../command-helpers/data-sources"));
 const studio_1 = require("../command-helpers/studio");
@@ -101,7 +100,7 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
             message: 'Protocol',
             choices: protocolChoices,
             skip: protocolChoices.includes(protocol),
-            result: value => {
+            result: (value) => {
                 protocol = protocol || value;
                 protocolInstance = new protocols_1.default(protocol);
                 return protocol;
@@ -119,7 +118,7 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
                 product === 'hosted-service' ||
                 studio !== undefined ||
                 node !== undefined,
-            result: value => {
+            result: (value) => {
                 // For now we only support NEAR subgraphs in the Hosted Service
                 if (protocol === 'near') {
                     // Can be overwritten because the question will be skipped (product === undefined)
@@ -138,7 +137,7 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
             name: 'subgraphName',
             message: () => product == 'subgraph-studio' || studio ? 'Subgraph slug' : 'Subgraph name',
             initial: subgraphName,
-            validate: name => {
+            validate: (name) => {
                 try {
                     (0, subgraph_1.validateSubgraphName)(name, { allowSimpleName });
                     return true;
@@ -152,7 +151,7 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
     $ graph init ${name} --allow-simple-name`;
                 }
             },
-            result: value => {
+            result: (value) => {
                 subgraphName = value;
                 return value;
             },
@@ -162,7 +161,7 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
             name: 'directory',
             message: 'Directory to create the subgraph in',
             initial: () => directory || (0, subgraph_1.getSubgraphBasename)(subgraphName),
-            validate: value => toolbox.filesystem.exists(value || directory || (0, subgraph_1.getSubgraphBasename)(subgraphName))
+            validate: (value) => toolbox.filesystem.exists(value || directory || (0, subgraph_1.getSubgraphBasename)(subgraphName))
                 ? 'Directory already exists'
                 : true,
         },
@@ -172,13 +171,16 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
             message: () => `${protocolInstance.displayName()} network`,
             choices: () => {
                 initDebug('Generating list of available networks for protocol "%s" (%M)', protocol, availableNetworks.get(protocol));
-                return availableNetworks
+                return (
+                // @ts-expect-error TODO: wait what?
+                availableNetworks
                     .get(protocol) // Get networks related to the chosen protocol.
-                    .toArray(); // Needed because of gluegun. It can't even receive a JS iterable.
+                    // @ts-expect-error TODO: wait what?
+                    .toArray()); // Needed because of gluegun. It can't even receive a JS iterable.
             },
             skip: fromExample !== undefined,
             initial: network || 'mainnet',
-            result: value => {
+            result: (value) => {
                 network = value;
                 return value;
             },
@@ -214,7 +216,8 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
                 if (protocolInstance.hasABIs() && !abi) {
                     try {
                         if (network === 'poa-core') {
-                            abiFromBlockScout = await (0, abi_1.loadAbiFromBlockScout)(ABI, network, value);
+                            // TODO: this variable is never used anywhere, what happens?
+                            // abiFromBlockScout = await loadAbiFromBlockScout(ABI, network, value)
                         }
                         else {
                             abiFromEtherscan = await (0, abi_1.loadAbiFromEtherscan)(ABI, network, value);
@@ -238,7 +241,7 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
                     return true;
                 }
                 try {
-                    abiFromFile = await loadAbiFromFile(ABI, value);
+                    abiFromFile = loadAbiFromFile(toolbox, ABI, value);
                     return true;
                 }
                 catch (e) {
@@ -252,8 +255,8 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
             message: 'Contract Name',
             initial: contractName || 'Contract',
             skip: () => fromExample !== undefined || !protocolInstance.hasContract(),
-            validate: value => value && value.length > 0,
-            result: value => {
+            validate: (value) => value && value.length > 0,
+            result: (value) => {
                 contractName = value;
                 return value;
             },
@@ -264,22 +267,28 @@ const processInitForm = async (toolbox, { protocol, product, studio, node, abi,
             message: 'Index contract events as entities',
             initial: true,
             skip: () => !!indexEvents,
-            result: value => {
+            result: (value) => {
                 indexEvents = value;
                 return value;
             },
         },
     ];
     try {
-        let answers = await toolbox.prompt.ask(questions);
-        return { ...answers, abi: abiFromEtherscan || abiFromFile, protocolInstance };
+        let answers = await toolbox.prompt.ask(
+        // @ts-expect-error questions do somehow fit
+        questions);
+        return {
+            ...answers,
+            abi: (abiFromEtherscan || abiFromFile),
+            protocolInstance,
+        };
     }
     catch (e) {
         return undefined;
     }
 };
-const loadAbiFromFile = async (ABI, filename) => {
-    let exists = await toolbox.filesystem.exists(filename);
+const loadAbiFromFile = (toolbox, ABI, filename) => {
+    let exists = toolbox.filesystem.exists(filename);
     if (!exists) {
         throw Error('File does not exist.');
     }
@@ -290,14 +299,14 @@ const loadAbiFromFile = async (ABI, filename) => {
         throw Error('Not sure what this path points to.');
     }
     else {
-        return await ABI.load('Contract', filename);
+        return ABI.load('Contract', filename);
     }
 };
 exports.default = {
     description: 'Creates a new subgraph with basic scaffolding',
     run: async (toolbox) => {
         // Obtain tools
-        let { print, system } = toolbox;
+        const { print, system } = toolbox;
         // Read CLI parameters
         let { protocol, product, studio, node, g, abi, allowSimpleName, fromContract, contractName, fromExample, h, help, indexEvents, network, } = toolbox.parameters.options;
         node = node || g;
@@ -334,15 +343,15 @@ exports.default = {
             return;
         }
         // Detect git
-        let git = await system.which('git');
+        let git = system.which('git');
         if (git === null) {
             print.error(`Git was not found on your system. Please install 'git' so it is in $PATH.`);
             process.exitCode = 1;
             return;
         }
         // Detect Yarn and/or NPM
-        let yarn = await system.which('yarn');
-        let npm = await system.which('npm');
+        let yarn = system.which('yarn');
+        let npm = system.which('npm');
         if (!yarn && !npm) {
             print.error(`Neither Yarn nor NPM were found on your system. Please install one of them.`);
             process.exitCode = 1;
@@ -371,7 +380,8 @@ exports.default = {
                 const ABI = protocolInstance.getABI();
                 if (abi) {
                     try {
-                        abi = await loadAbiFromFile(ABI, abi);
+                        // @ts-expect-error TODO: how does this even work when the filename is expected?
+                        abi = loadAbiFromFile(ABI, abi);
                     }
                     catch (e) {
                         print.error(`Failed to load ABI: ${e.message}`);
@@ -480,12 +490,12 @@ const revalidateSubgraphName = async (toolbox, subgraphName, { allowSimpleName }
         return false;
     }
 };
-const initRepository = async (toolbox, directory) => await (0, spinner_1.withSpinner)(`Initialize subgraph repository`, `Failed to initialize subgraph repository`, `Warnings while initializing subgraph repository`, async (spinner) => {
+const initRepository = async (toolbox, directory) => await (0, spinner_1.withSpinner)(`Initialize subgraph repository`, `Failed to initialize subgraph repository`, `Warnings while initializing subgraph repository`, async () => {
     // Remove .git dir in --from-example mode; in --from-contract, we're
     // starting from an empty directory
     let gitDir = path_1.default.join(directory, '.git');
     if (toolbox.filesystem.exists(gitDir)) {
-        await toolbox.filesystem.remove(gitDir);
+        toolbox.filesystem.remove(gitDir);
     }
     await toolbox.system.run('git init', { cwd: directory });
     await toolbox.system.run('git add --all', { cwd: directory });
@@ -504,18 +514,18 @@ const npmLinkToLocalCli = async (toolbox, directory) => {
         await toolbox.system.run('npm link @graphprotocol/graph-cli', { cwd: directory });
     }
 };
-const installDependencies = async (toolbox, directory, installCommand) => await (0, spinner_1.withSpinner)(`Install dependencies with ${toolbox.print.colors.muted(installCommand)}`, `Failed to install dependencies`, `Warnings while installing dependencies`, async (spinner) => {
+const installDependencies = async (toolbox, directory, installCommand) => await (0, spinner_1.withSpinner)(`Install dependencies with ${toolbox.print.colors.muted(installCommand)}`, `Failed to install dependencies`, `Warnings while installing dependencies`, async () => {
     // Links to local graph-cli if we're running the automated tests
     await npmLinkToLocalCli(toolbox, directory);
     await toolbox.system.run(installCommand, { cwd: directory });
     return true;
 });
-const runCodegen = async (toolbox, directory, codegenCommand) => await (0, spinner_1.withSpinner)(`Generate ABI and schema types with ${toolbox.print.colors.muted(codegenCommand)}`, `Failed to generate code from ABI and GraphQL schema`, `Warnings while generating code from ABI and GraphQL schema`, async (spinner) => {
+const runCodegen = async (toolbox, directory, codegenCommand) => await (0, spinner_1.withSpinner)(`Generate ABI and schema types with ${toolbox.print.colors.muted(codegenCommand)}`, `Failed to generate code from ABI and GraphQL schema`, `Warnings while generating code from ABI and GraphQL schema`, async () => {
     await toolbox.system.run(codegenCommand, { cwd: directory });
     return true;
 });
-const printNextSteps = (toolbox, { subgraphName, directory }, { commands }) => {
-    let { print } = toolbox;
+const printNextSteps = (toolbox, { subgraphName, directory }, { commands, }) => {
+    const { print } = toolbox;
     let relativeDir = path_1.default.relative(process.cwd(), directory);
     // Print instructions
     print.success(`
@@ -531,10 +541,10 @@ Subgraph ${print.colors.blue(subgraphName)} created in ${print.colors.blue(relat
 
 Make sure to visit the documentation on https://thegraph.com/docs/ for further information.`);
 };
-const initSubgraphFromExample = async (toolbox, { fromExample, allowSimpleName, subgraphName, directory, studio, product }, { commands }) => {
+const initSubgraphFromExample = async (toolbox, { fromExample, allowSimpleName, subgraphName, directory, studio, product, }, { commands, }) => {
     let { filesystem, print, system } = toolbox;
     // Fail if the subgraph name is invalid
-    if (!revalidateSubgraphName(toolbox, subgraphName, { allowSimpleName })) {
+    if (!revalidateSubgraphName(toolbox, subgraphName, { allowSimpleName: !!allowSimpleName })) {
         process.exitCode = 1;
         return;
     }
@@ -545,7 +555,7 @@ const initSubgraphFromExample = async (toolbox, { fromExample, allowSimpleName,
         return;
     }
     // Clone the example subgraph repository
-    let cloned = await (0, spinner_1.withSpinner)(`Cloning example subgraph`, `Failed to clone example subgraph`, `Warnings while cloning example subgraph`, async (spinner) => {
+    let cloned = await (0, spinner_1.withSpinner)(`Cloning example subgraph`, `Failed to clone example subgraph`, `Warnings while cloning example subgraph`, async () => {
         // Create a temporary directory
         const prefix = path_1.default.join(os_1.default.tmpdir(), 'example-subgraph-');
         const tmpDir = fs_1.default.mkdtempSync(prefix);
@@ -555,7 +565,7 @@ const initSubgraphFromExample = async (toolbox, { fromExample, allowSimpleName,
             if (fromExample === undefined || fromExample === true) {
                 fromExample = DEFAULT_EXAMPLE_SUBGRAPH;
             }
-            const exampleSubgraphPath = path_1.default.join(tmpDir, fromExample);
+            const exampleSubgraphPath = path_1.default.join(tmpDir, String(fromExample));
             if (!filesystem.exists(exampleSubgraphPath)) {
                 return { result: false, error: `Example not found: ${fromExample}` };
             }
@@ -589,7 +599,7 @@ const initSubgraphFromExample = async (toolbox, { fromExample, allowSimpleName,
         return;
     }
     // Update package.json to match the subgraph name
-    let prepared = await (0, spinner_1.withSpinner)(`Update subgraph name and commands in package.json`, `Failed to update subgraph name and commands in package.json`, `Warnings while updating subgraph name and commands in package.json`, async (spinner) => {
+    let prepared = await (0, spinner_1.withSpinner)(`Update subgraph name and commands in package.json`, `Failed to update subgraph name and commands in package.json`, `Warnings while updating subgraph name and commands in package.json`, async () => {
         try {
             // Load package.json
             let pkgJsonFilename = filesystem.path(directory, 'package.json');
@@ -638,7 +648,7 @@ const initSubgraphFromExample = async (toolbox, { fromExample, allowSimpleName,
     }
     printNextSteps(toolbox, { subgraphName, directory }, { commands });
 };
-const initSubgraphFromContract = async (toolbox, { protocolInstance, allowSimpleName, subgraphName, directory, abi, network, contract, indexEvents, contractName, node, studio, product, }, { commands, addContract }) => {
+const initSubgraphFromContract = async (toolbox, { protocolInstance, allowSimpleName, subgraphName, directory, abi, network, contract, indexEvents, contractName, node, studio, product, }, { commands, addContract, }) => {
     let { print } = toolbox;
     // Fail if the subgraph name is invalid
     if (!revalidateSubgraphName(toolbox, subgraphName, { allowSimpleName })) {
@@ -651,7 +661,10 @@ const initSubgraphFromContract = async (toolbox, { protocolInstance, allowSimple
         process.exitCode = 1;
         return;
     }
-    if (protocolInstance.hasABIs() && (0, schema_1.abiEvents)(abi).length === 0) {
+    if (protocolInstance.hasABIs() &&
+        ((0, schema_1.abiEvents)(abi).size === 0 ||
+            // @ts-expect-error TODO: the abiEvents result is expected to be a List, how's it an array?
+            (0, schema_1.abiEvents)(abi).length === 0)) {
         // Fail if the ABI does not contain any events
         print.error(`ABI does not contain any events`);
         process.exitCode = 1;
@@ -721,7 +734,7 @@ const initSubgraphFromContract = async (toolbox, { protocolInstance, allowSimple
 const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
     const addContractConfirmation = await toolbox.prompt.confirm('Add another contract?');
     if (addContractConfirmation) {
-        let abiFromFile;
+        let abiFromFile = false;
         let ProtocolContract = protocolInstance.getContract();
         let questions = [
             {
@@ -739,7 +752,7 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
                 name: 'localAbi',
                 message: 'Provide local ABI path?',
                 choices: ['yes', 'no'],
-                result: value => {
+                result: (value) => {
                     abiFromFile = value === 'yes' ? true : false;
                     return abiFromFile;
                 },
@@ -755,13 +768,15 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
                 name: 'contractName',
                 message: 'Contract Name',
                 initial: 'Contract',
-                validate: value => value && value.length > 0,
+                validate: (value) => value && value.length > 0,
             },
         ];
         // Get the cwd before process.chdir in order to switch back in the end of command execution
         const cwd = process.cwd();
         try {
-            let { abi, contract, contractName } = await toolbox.prompt.ask(questions);
+            let { abi, contract, contractName } = await toolbox.prompt.ask(
+            // @ts-expect-error questions do somehow fit
+            questions);
             if (fs_1.default.existsSync(directory)) {
                 process.chdir(directory);
             }
@@ -774,7 +789,7 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
                     commandLine.push('--abi', abi);
                 }
             }
-            await cli_1.default.run(commandLine);
+            await graphCli.run(commandLine);
         }
         catch (e) {
             toolbox.print.error(e);

package/dist/protocols/contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/protocols/near/contract.js

@@ -10,6 +10,7 @@ class NearContract {
     }
     constructor(account) {
         this.account = account;
+        this.account = account;
     }
     validateLength(value) {
         return (value.length >= MINIMUM_ACCOUNT_ID_LENGTH &&

package/dist/subgraph.js

@@ -32,7 +32,7 @@ const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const types_1 = require("yaml/types");
 const graphql = __importStar(require("graphql/language"));
-const validation_1 = __importDefault(require("./validation"));
+const validation = __importStar(require("./validation"));
 const debug_1 = __importDefault(require("./debug"));
 let subgraphDebug = (0, debug_1.default)('graph-cli:subgraph');
 const throwCombinedError = (filename, errors) => {
@@ -72,11 +72,11 @@ class Subgraph {
             return definition.name.value === 'SubgraphManifest';
         });
         // Validate the subgraph manifest using this schema
-        return validation_1.default.validateManifest(data, rootType, schema, protocol, { resolveFile });
+        return validation.validateManifest(data, rootType, schema, protocol, { resolveFile });
     }
     static validateSchema(manifest, { resolveFile }) {
         let filename = resolveFile(manifest.getIn(['schema', 'file']));
-        const validationErrors = validation_1.default.validateSchema(filename);
+        const validationErrors = validation.validateSchema(filename);
         let errors;
         if (validationErrors.size > 0) {
             errors = validationErrors.groupBy(error => error.get('entity')).sort();
@@ -154,7 +154,7 @@ At least one such handler must be defined.`,
         if (!protocol.hasContract()) {
             return immutable_1.default.List();
         }
-        return validation_1.default.validateContractValues(manifest, protocol);
+        return validation.validateContractValues(manifest, protocol);
     }
     // Validate that data source names are unique, so they don't overwrite each other.
     static validateUniqueDataSourceNames(manifest) {

package/dist/validation/index.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateContract = exports.validateContractValues = exports.validateManifest = exports.validateSchema = void 0;
 const schema_1 = require("./schema");
+Object.defineProperty(exports, "validateSchema", { enumerable: true, get: function () { return schema_1.validateSchema; } });
 const manifest_1 = require("./manifest");
+Object.defineProperty(exports, "validateManifest", { enumerable: true, get: function () { return manifest_1.validateManifest; } });
 const contract_1 = require("./contract");
-exports.default = {
-    validateSchema: schema_1.validateSchema,
-    validateManifest: manifest_1.validateManifest,
-    validateContractValues: contract_1.validateContractValues,
-    validateContract: contract_1.validateContract,
-};
+Object.defineProperty(exports, "validateContractValues", { enumerable: true, get: function () { return contract_1.validateContractValues; } });
+Object.defineProperty(exports, "validateContract", { enumerable: true, get: function () { return contract_1.validateContract; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.37.3-alpha-20230112195908-6a078ea",
+  "version": "0.37.3-alpha-20230112205341-caa8660",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "main": "dist/cli.js",

package/src/command-helpers/abi.ts

@@ -7,7 +7,7 @@ export const loadAbiFromEtherscan = async (
   ABICtor: typeof ABI,
   network: string,
   address: string,
-) =>
+): Promise<ABI> =>
   await withSpinner(
     `Fetching ABI from Etherscan`,
     `Failed to fetch ABI from Etherscan`,

package/src/command-helpers/studio.test.ts

@@ -37,7 +37,6 @@ describe('Version Command Helpers', () => {
         expect(() =>
           validateStudioNetwork({
             product: 'subgraph-studio',
-            // @ts-expect-error for tests sake
             network: 'celo',
           }),
         ).toThrow(
@@ -69,9 +68,7 @@ describe('Version Command Helpers', () => {
       test("And it's NOT an allowed network", () => {
         expect(() =>
           validateStudioNetwork({
-            // @ts-expect-error for tests sake
             product: 'hosted-service',
-            // @ts-expect-error for tests sake
             network: 'celo',
           }),
         ).not.toThrow(

package/src/command-helpers/studio.ts

@@ -1,12 +1,19 @@
-const allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli', 'gnosis'] as const
+export const allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli', 'gnosis'] as const
 
-const validateStudioNetwork = ({ studio, product, network }:{
-  studio?: boolean
-  product?: 'subgraph-studio'
-  network: typeof allowedStudioNetworks[number]
+export const validateStudioNetwork = ({
+  studio,
+  product,
+  network,
+}: {
+  studio?: string | boolean
+  product?: string
+  network: string
 }) => {
   let isStudio = studio || product === 'subgraph-studio'
-  let isAllowedNetwork = allowedStudioNetworks.includes(network)
+  let isAllowedNetwork = allowedStudioNetworks.includes(
+    // @ts-expect-error we're checking if the network is allowed
+    network,
+  )
 
   if (isStudio && !isAllowedNetwork) {
     throw new Error(
@@ -16,5 +23,3 @@ const validateStudioNetwork = ({ studio, product, network }:{
     )
   }
 }
-
-export { allowedStudioNetworks, validateStudioNetwork }

package/src/command-helpers/subgraph.ts

@@ -1,6 +1,6 @@
-const validateSubgraphName = (
+export const validateSubgraphName = (
   name: string,
-  { allowSimpleName }: { allowSimpleName: string },
+  { allowSimpleName }: { allowSimpleName?: boolean },
 ) => {
   if (allowSimpleName) {
     return name
@@ -16,9 +16,7 @@ You can bypass this check with --allow-simple-name.`)
   }
 }
 
-const getSubgraphBasename = (name: string) => {
+export const getSubgraphBasename = (name: string) => {
   let segments = name.split('/', 2)
   return segments[segments.length - 1]
 }
-
-export { validateSubgraphName, getSubgraphBasename }

package/src/commands/build.ts

@@ -118,7 +118,7 @@ export default {
     }
 
     if (network) {
-      let identifierName = protocol.getContract().identifierName()
+      let identifierName = protocol.getContract()!.identifierName()
       await updateSubgraphNetwork(toolbox, manifest, network, networkFile, identifierName)
     }
 

package/src/commands/deploy.ts

@@ -252,7 +252,7 @@ export default {
     }
 
     if (network) {
-      let identifierName = protocol.getContract().identifierName()
+      let identifierName = protocol.getContract()!.identifierName()
       await updateSubgraphNetwork(toolbox, manifest, network, networkFile, identifierName)
     }
 

package/src/commands/{init.js → init.ts}

@@ -1,22 +1,24 @@
 import chalk from 'chalk'
 import os from 'os'
 import path from 'path'
-import * as toolbox from 'gluegun/toolbox'
+import { GluegunToolbox } from 'gluegun'
 import fs from 'fs'
-import graphCli from '../cli'
+import * as graphCli from '../cli'
 import { getSubgraphBasename, validateSubgraphName } from '../command-helpers/subgraph'
 import * as DataSourcesExtractor from '../command-helpers/data-sources'
 import { validateStudioNetwork } from '../command-helpers/studio'
 import { initNetworksConfig } from '../command-helpers/network'
-import { withSpinner, step } from '../command-helpers/spinner'
+import { withSpinner } from '../command-helpers/spinner'
 import { fixParameters } from '../command-helpers/gluegun'
 import { chooseNodeUrl } from '../command-helpers/node'
 import { loadAbiFromEtherscan, loadAbiFromBlockScout } from '../command-helpers/abi'
 import { generateScaffold, writeScaffold } from '../command-helpers/scaffold'
 import { abiEvents } from '../scaffold/schema'
 import { validateContract } from '../validation'
-import Protocol from '../protocols'
+import Protocol, { ProtocolName } from '../protocols'
 import debug from '../debug'
+import EthereumABI from '../protocols/ethereum/abi'
+import { ContractCtor } from '../protocols/contract'
 
 const protocolChoices = Array.from(Protocol.availableProtocols().keys())
 const availableNetworks = Protocol.availableNetworks()
@@ -51,22 +53,22 @@ ${chalk.dim('Options for --from-contract:')}
 ${chalk.dim.underline('Ethereum:')}
 
       --abi <path>               Path to the contract ABI (default: download from Etherscan)
-      --network <${availableNetworks.get('ethereum').join('|')}>
+      --network <${availableNetworks.get('ethereum')!.join('|')}>
                                  Selects the network the contract is deployed to
 
 ${chalk.dim.underline('NEAR:')}
 
-      --network <${availableNetworks.get('near').join('|')}>
+      --network <${availableNetworks.get('near')!.join('|')}>
                                  Selects the network the contract is deployed to
 
 ${chalk.dim.underline('Cosmos:')}
 
-      --network <${availableNetworks.get('cosmos').join('|')}>
+      --network <${availableNetworks.get('cosmos')!.join('|')}>
                                  Selects the network the contract is deployed to
 `
 
 const processInitForm = async (
-  toolbox,
+  toolbox: GluegunToolbox,
   {
     protocol,
     product,
@@ -81,13 +83,41 @@ const processInitForm = async (
     network,
     subgraphName,
     contractName,
+  }: {
+    protocol: ProtocolName
+    product: string
+    studio: string
+    node: string
+    abi: EthereumABI
+    allowSimpleName: boolean
+    directory: string
+    contract: string
+    indexEvents: boolean
+    fromExample: string | boolean
+    network: string
+    subgraphName: string
+    contractName: string
   },
-) => {
-  let abiFromEtherscan = undefined
+): Promise<
+  | {
+      abi: EthereumABI
+      protocolInstance: Protocol
+      subgraphName: string
+      directory: string
+      studio: string
+      product: string
+      network: string
+      contract: string
+      indexEvents: boolean
+      contractName: string
+    }
+  | undefined
+> => {
+  let abiFromEtherscan: EthereumABI | undefined = undefined
   let abiFromFile = undefined
-  let protocolInstance
-  let ProtocolContract
-  let ABI
+  let protocolInstance!: Protocol
+  let ProtocolContract: ContractCtor
+  let ABI: typeof EthereumABI
 
   let questions = [
     {
@@ -96,7 +126,7 @@ const processInitForm = async (
       message: 'Protocol',
       choices: protocolChoices,
       skip: protocolChoices.includes(protocol),
-      result: value => {
+      result: (value: string) => {
         protocol = protocol || value
         protocolInstance = new Protocol(protocol)
         return protocol
@@ -115,7 +145,7 @@ const processInitForm = async (
         product === 'hosted-service' ||
         studio !== undefined ||
         node !== undefined,
-      result: value => {
+      result: (value: string | undefined) => {
         // For now we only support NEAR subgraphs in the Hosted Service
         if (protocol === 'near') {
           // Can be overwritten because the question will be skipped (product === undefined)
@@ -127,7 +157,7 @@ const processInitForm = async (
           allowSimpleName = true
         }
 
-        product = value
+        product = value as any
         return value
       },
     },
@@ -137,7 +167,7 @@ const processInitForm = async (
       message: () =>
         product == 'subgraph-studio' || studio ? 'Subgraph slug' : 'Subgraph name',
       initial: subgraphName,
-      validate: name => {
+      validate: (name: string) => {
         try {
           validateSubgraphName(name, { allowSimpleName })
           return true
@@ -150,7 +180,7 @@ const processInitForm = async (
     $ graph init ${name} --allow-simple-name`
         }
       },
-      result: value => {
+      result: (value: string) => {
         subgraphName = value
         return value
       },
@@ -160,7 +190,7 @@ const processInitForm = async (
       name: 'directory',
       message: 'Directory to create the subgraph in',
       initial: () => directory || getSubgraphBasename(subgraphName),
-      validate: value =>
+      validate: (value: string) =>
         toolbox.filesystem.exists(value || directory || getSubgraphBasename(subgraphName))
           ? 'Directory already exists'
           : true,
@@ -173,16 +203,20 @@ const processInitForm = async (
         initDebug(
           'Generating list of available networks for protocol "%s" (%M)',
           protocol,
-          availableNetworks.get(protocol),
+          availableNetworks.get(protocol as any),
         )
-        return availableNetworks
-          .get(protocol) // Get networks related to the chosen protocol.
-          .toArray() // Needed because of gluegun. It can't even receive a JS iterable.
+        return (
+          // @ts-expect-error TODO: wait what?
+          availableNetworks
+            .get(protocol) // Get networks related to the chosen protocol.
+            // @ts-expect-error TODO: wait what?
+            .toArray()
+        ) // Needed because of gluegun. It can't even receive a JS iterable.
       },
 
       skip: fromExample !== undefined,
       initial: network || 'mainnet',
-      result: value => {
+      result: (value: string) => {
         network = value
         return value
       },
@@ -196,12 +230,12 @@ const processInitForm = async (
       type: 'input',
       name: 'contract',
       message: () => {
-        ProtocolContract = protocolInstance.getContract()
+        ProtocolContract = protocolInstance.getContract()!
         return `Contract ${ProtocolContract.identifierName()}`
       },
       skip: () => fromExample !== undefined || !protocolInstance.hasContract(),
       initial: contract,
-      validate: async value => {
+      validate: async (value: string) => {
         if (fromExample !== undefined || !protocolInstance.hasContract()) {
           return true
         }
@@ -211,7 +245,7 @@ const processInitForm = async (
 
         return valid ? true : error
       },
-      result: async value => {
+      result: async (value: string) => {
         if (fromExample !== undefined) {
           return value
         }
@@ -222,9 +256,10 @@ const processInitForm = async (
         if (protocolInstance.hasABIs() && !abi) {
           try {
             if (network === 'poa-core') {
-              abiFromBlockScout = await loadAbiFromBlockScout(ABI, network, value)
+              // TODO: this variable is never used anywhere, what happens?
+              // abiFromBlockScout = await loadAbiFromBlockScout(ABI, network, value)
             } else {
-              abiFromEtherscan = await loadAbiFromEtherscan(ABI, network, value)
+              abiFromEtherscan = await loadAbiFromEtherscan(ABI, network!, value)
             }
           } catch (e) {}
         }
@@ -240,13 +275,13 @@ const processInitForm = async (
         !protocolInstance.hasABIs() ||
         fromExample !== undefined ||
         abiFromEtherscan !== undefined,
-      validate: async value => {
+      validate: async (value: string) => {
         if (fromExample || abiFromEtherscan || !protocolInstance.hasABIs()) {
           return true
         }
 
         try {
-          abiFromFile = await loadAbiFromFile(ABI, value)
+          abiFromFile = loadAbiFromFile(toolbox, ABI, value)
           return true
         } catch (e) {
           return e.message
@@ -259,8 +294,8 @@ const processInitForm = async (
       message: 'Contract Name',
       initial: contractName || 'Contract',
       skip: () => fromExample !== undefined || !protocolInstance.hasContract(),
-      validate: value => value && value.length > 0,
-      result: value => {
+      validate: (value: string) => value && value.length > 0,
+      result: (value: string) => {
         contractName = value
         return value
       },
@@ -271,7 +306,7 @@ const processInitForm = async (
       message: 'Index contract events as entities',
       initial: true,
       skip: () => !!indexEvents,
-      result: value => {
+      result: (value: boolean) => {
         indexEvents = value
         return value
       },
@@ -279,15 +314,26 @@ const processInitForm = async (
   ]
 
   try {
-    let answers = await toolbox.prompt.ask(questions)
-    return { ...answers, abi: abiFromEtherscan || abiFromFile, protocolInstance }
+    let answers = await toolbox.prompt.ask(
+      // @ts-expect-error questions do somehow fit
+      questions,
+    )
+    return {
+      ...(answers as any), // necessary answers are here
+      abi: (abiFromEtherscan || abiFromFile)!,
+      protocolInstance,
+    }
   } catch (e) {
     return undefined
   }
 }
 
-const loadAbiFromFile = async (ABI, filename) => {
-  let exists = await toolbox.filesystem.exists(filename)
+const loadAbiFromFile = (
+  toolbox: GluegunToolbox,
+  ABI: typeof EthereumABI,
+  filename: string,
+) => {
+  let exists = toolbox.filesystem.exists(filename)
 
   if (!exists) {
     throw Error('File does not exist.')
@@ -296,15 +342,15 @@ const loadAbiFromFile = async (ABI, filename) => {
   } else if (exists === 'other') {
     throw Error('Not sure what this path points to.')
   } else {
-    return await ABI.load('Contract', filename)
+    return ABI.load('Contract', filename)
   }
 }
 
 export default {
   description: 'Creates a new subgraph with basic scaffolding',
-  run: async toolbox => {
+  run: async (toolbox: GluegunToolbox) => {
     // Obtain tools
-    let { print, system } = toolbox
+    const { print, system } = toolbox
 
     // Read CLI parameters
     let {
@@ -360,7 +406,7 @@ export default {
     }
 
     // Detect git
-    let git = await system.which('git')
+    let git = system.which('git')
     if (git === null) {
       print.error(
         `Git was not found on your system. Please install 'git' so it is in $PATH.`,
@@ -370,8 +416,8 @@ export default {
     }
 
     // Detect Yarn and/or NPM
-    let yarn = await system.which('yarn')
-    let npm = await system.which('npm')
+    let yarn = system.which('yarn')
+    let npm = system.which('npm')
     if (!yarn && !npm) {
       print.error(
         `Neither Yarn nor NPM were found on your system. Please install one of them.`,
@@ -415,7 +461,8 @@ export default {
         const ABI = protocolInstance.getABI()
         if (abi) {
           try {
-            abi = await loadAbiFromFile(ABI, abi)
+            // @ts-expect-error TODO: how does this even work when the filename is expected?
+            abi = loadAbiFromFile(ABI, abi)
           } catch (e) {
             print.error(`Failed to load ABI: ${e.message}`)
             process.exitCode = 1
@@ -520,7 +567,11 @@ export default {
   },
 }
 
-const revalidateSubgraphName = async (toolbox, subgraphName, { allowSimpleName }) => {
+const revalidateSubgraphName = async (
+  toolbox: GluegunToolbox,
+  subgraphName: string,
+  { allowSimpleName }: { allowSimpleName: boolean },
+) => {
   // Fail if the subgraph name is invalid
   try {
     validateSubgraphName(subgraphName, { allowSimpleName })
@@ -536,17 +587,17 @@ const revalidateSubgraphName = async (toolbox, subgraphName, { allowSimpleName }
   }
 }
 
-const initRepository = async (toolbox, directory) =>
+const initRepository = async (toolbox: GluegunToolbox, directory: string) =>
   await withSpinner(
     `Initialize subgraph repository`,
     `Failed to initialize subgraph repository`,
     `Warnings while initializing subgraph repository`,
-    async spinner => {
+    async () => {
       // Remove .git dir in --from-example mode; in --from-contract, we're
       // starting from an empty directory
       let gitDir = path.join(directory, '.git')
       if (toolbox.filesystem.exists(gitDir)) {
-        await toolbox.filesystem.remove(gitDir)
+        toolbox.filesystem.remove(gitDir)
       }
       await toolbox.system.run('git init', { cwd: directory })
       await toolbox.system.run('git add --all', { cwd: directory })
@@ -562,18 +613,22 @@ const initRepository = async (toolbox, directory) =>
 // This requires that the command `npm link` is called
 // on the root directory of this repository, as described here:
 // https://docs.npmjs.com/cli/v7/commands/npm-link.
-const npmLinkToLocalCli = async (toolbox, directory) => {
+const npmLinkToLocalCli = async (toolbox: GluegunToolbox, directory: string) => {
   if (process.env.GRAPH_CLI_TESTS) {
     await toolbox.system.run('npm link @graphprotocol/graph-cli', { cwd: directory })
   }
 }
 
-const installDependencies = async (toolbox, directory, installCommand) =>
+const installDependencies = async (
+  toolbox: GluegunToolbox,
+  directory: string,
+  installCommand: string,
+) =>
   await withSpinner(
     `Install dependencies with ${toolbox.print.colors.muted(installCommand)}`,
     `Failed to install dependencies`,
     `Warnings while installing dependencies`,
-    async spinner => {
+    async () => {
       // Links to local graph-cli if we're running the automated tests
       await npmLinkToLocalCli(toolbox, directory)
 
@@ -582,19 +637,35 @@ const installDependencies = async (toolbox, directory, installCommand) =>
     },
   )
 
-const runCodegen = async (toolbox, directory, codegenCommand) =>
+const runCodegen = async (
+  toolbox: GluegunToolbox,
+  directory: string,
+  codegenCommand: string,
+) =>
   await withSpinner(
     `Generate ABI and schema types with ${toolbox.print.colors.muted(codegenCommand)}`,
     `Failed to generate code from ABI and GraphQL schema`,
     `Warnings while generating code from ABI and GraphQL schema`,
-    async spinner => {
+    async () => {
       await toolbox.system.run(codegenCommand, { cwd: directory })
       return true
     },
   )
 
-const printNextSteps = (toolbox, { subgraphName, directory }, { commands }) => {
-  let { print } = toolbox
+const printNextSteps = (
+  toolbox: GluegunToolbox,
+  { subgraphName, directory }: { subgraphName: string; directory: string },
+  {
+    commands,
+  }: {
+    commands: {
+      install: string
+      codegen: string
+      deploy: string
+    }
+  },
+) => {
+  const { print } = toolbox
 
   let relativeDir = path.relative(process.cwd(), directory)
 
@@ -616,14 +687,38 @@ Make sure to visit the documentation on https://thegraph.com/docs/ for further i
 }
 
 const initSubgraphFromExample = async (
-  toolbox,
-  { fromExample, allowSimpleName, subgraphName, directory, studio, product },
-  { commands },
+  toolbox: GluegunToolbox,
+  {
+    fromExample,
+    allowSimpleName,
+    subgraphName,
+    directory,
+    studio,
+    product,
+  }: {
+    fromExample: string | boolean
+    allowSimpleName?: boolean
+    subgraphName: string
+    directory: string
+    studio: string
+    product: string
+  },
+  {
+    commands,
+  }: {
+    commands: {
+      install: string
+      codegen: string
+      deploy: string
+    }
+  },
 ) => {
   let { filesystem, print, system } = toolbox
 
   // Fail if the subgraph name is invalid
-  if (!revalidateSubgraphName(toolbox, subgraphName, { allowSimpleName })) {
+  if (
+    !revalidateSubgraphName(toolbox, subgraphName, { allowSimpleName: !!allowSimpleName })
+  ) {
     process.exitCode = 1
     return
   }
@@ -640,7 +735,7 @@ const initSubgraphFromExample = async (
     `Cloning example subgraph`,
     `Failed to clone example subgraph`,
     `Warnings while cloning example subgraph`,
-    async spinner => {
+    async () => {
       // Create a temporary directory
       const prefix = path.join(os.tmpdir(), 'example-subgraph-')
       const tmpDir = fs.mkdtempSync(prefix)
@@ -655,7 +750,7 @@ const initSubgraphFromExample = async (
           fromExample = DEFAULT_EXAMPLE_SUBGRAPH
         }
 
-        const exampleSubgraphPath = path.join(tmpDir, fromExample)
+        const exampleSubgraphPath = path.join(tmpDir, String(fromExample))
 
         if (!filesystem.exists(exampleSubgraphPath)) {
           return { result: false, error: `Example not found: ${fromExample}` }
@@ -700,7 +795,7 @@ const initSubgraphFromExample = async (
     `Update subgraph name and commands in package.json`,
     `Failed to update subgraph name and commands in package.json`,
     `Warnings while updating subgraph name and commands in package.json`,
-    async spinner => {
+    async () => {
       try {
         // Load package.json
         let pkgJsonFilename = filesystem.path(directory, 'package.json')
@@ -758,7 +853,7 @@ const initSubgraphFromExample = async (
 }
 
 const initSubgraphFromContract = async (
-  toolbox,
+  toolbox: GluegunToolbox,
   {
     protocolInstance,
     allowSimpleName,
@@ -772,8 +867,31 @@ const initSubgraphFromContract = async (
     node,
     studio,
     product,
+  }: {
+    protocolInstance: Protocol
+    allowSimpleName: boolean
+    subgraphName: string
+    directory: string
+    abi: EthereumABI
+    network: string
+    contract: string
+    indexEvents: boolean
+    contractName: string
+    node: string
+    studio: string
+    product: string
+  },
+  {
+    commands,
+    addContract,
+  }: {
+    commands: {
+      install: string
+      codegen: string
+      deploy: string
+    }
+    addContract: boolean
   },
-  { commands, addContract },
 ) => {
   let { print } = toolbox
 
@@ -790,7 +908,12 @@ const initSubgraphFromContract = async (
     return
   }
 
-  if (protocolInstance.hasABIs() && abiEvents(abi).length === 0) {
+  if (
+    protocolInstance.hasABIs() &&
+    (abiEvents(abi).size === 0 ||
+      // @ts-expect-error TODO: the abiEvents result is expected to be a List, how's it an array?
+      abiEvents(abi).length === 0)
+  ) {
     // Fail if the ABI does not contain any events
     print.error(`ABI does not contain any events`)
     process.exitCode = 1
@@ -837,7 +960,7 @@ const initSubgraphFromContract = async (
   }
 
   if (protocolInstance.hasContract()) {
-    let identifierName = protocolInstance.getContract().identifierName()
+    let identifierName = protocolInstance.getContract()!.identifierName()
     let networkConf = await initNetworksConfig(toolbox, directory, identifierName)
     if (networkConf !== true) {
       process.exitCode = 1
@@ -873,19 +996,22 @@ const initSubgraphFromContract = async (
   printNextSteps(toolbox, { subgraphName, directory }, { commands })
 }
 
-const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
+const addAnotherContract = async (
+  toolbox: GluegunToolbox,
+  { protocolInstance, directory }: { protocolInstance: Protocol; directory: string },
+) => {
   const addContractConfirmation = await toolbox.prompt.confirm('Add another contract?')
 
   if (addContractConfirmation) {
-    let abiFromFile
-    let ProtocolContract = protocolInstance.getContract()
+    let abiFromFile: boolean = false
+    let ProtocolContract = protocolInstance.getContract()!
 
     let questions = [
       {
         type: 'input',
         name: 'contract',
         message: () => `Contract ${ProtocolContract.identifierName()}`,
-        validate: async value => {
+        validate: async (value: string) => {
           // Validate whether the contract is valid
           const { valid, error } = validateContract(value, ProtocolContract)
           return valid ? true : error
@@ -896,7 +1022,7 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
         name: 'localAbi',
         message: 'Provide local ABI path?',
         choices: ['yes', 'no'],
-        result: value => {
+        result: (value: string) => {
           abiFromFile = value === 'yes' ? true : false
           return abiFromFile
         },
@@ -912,7 +1038,7 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
         name: 'contractName',
         message: 'Contract Name',
         initial: 'Contract',
-        validate: value => value && value.length > 0,
+        validate: (value: string) => value && value.length > 0,
       },
     ]
 
@@ -920,7 +1046,10 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
     const cwd = process.cwd()
 
     try {
-      let { abi, contract, contractName } = await toolbox.prompt.ask(questions)
+      let { abi, contract, contractName } = await toolbox.prompt.ask(
+        // @ts-expect-error questions do somehow fit
+        questions,
+      )
 
       if (fs.existsSync(directory)) {
         process.chdir(directory)

package/src/protocols/contract.ts

@@ -0,0 +1,9 @@
+// TODO: make sure the classes implement this type
+export interface ContractCtor {
+  new (account: string): Contract
+  identifierName(): string
+}
+
+export interface Contract {
+  validate(): { valid: boolean; error: string | null }
+}

package/src/protocols/ethereum/contract.ts

@@ -1,4 +1,6 @@
-export default class EthereumContract {
+import { Contract } from '../contract'
+
+export default class EthereumContract implements Contract {
   static identifierName() {
     return 'address'
   }

package/src/protocols/index.ts

@@ -21,6 +21,7 @@ import * as CosmosMappingScaffold from './cosmos/scaffold/mapping'
 import debug from '../debug'
 import Subgraph from '../subgraph'
 import { SubgraphOptions } from './subgraph'
+import { ContractCtor } from './contract'
 
 let protocolDebug = debug('graph-cli:protocol')
 
@@ -113,7 +114,10 @@ export default class Protocol {
         'juno-1',
         'uni-3', // Juno testnet
       ],
-    }) as immutable.Map<string, string[]>
+    }) as immutable.Map<
+      'arweave' | 'ethereum' | 'near' | 'cosmos' | 'substreams',
+      string[]
+    >
 
     let allNetworks: string[] = []
     networks.forEach(value => {
@@ -210,7 +214,7 @@ export type ProtocolName = 'arweave' | 'ethereum' | 'near' | 'cosmos' | 'substre
 export interface ProtocolConfig {
   displayName: string
   abi?: any
-  contract?: any
+  contract?: ContractCtor
   getTemplateCodeGen?: (template: any) => any
   getTypeGenerator?: (options: any) => any
   getSubgraph(options: SubgraphOptions): Subgraph

package/src/protocols/near/contract.ts

@@ -1,16 +1,16 @@
+import { Contract } from '../contract'
+
 const MINIMUM_ACCOUNT_ID_LENGTH = 2 as const
 const MAXIMUM_ACCOUNT_ID_LENGTH = 64 as const
 
 const RULES_URL = 'https://docs.near.org/docs/concepts/account#account-id-rules' as const
 
-export default class NearContract {
-  private account: string
-
+export default class NearContract implements Contract {
   static identifierName() {
     return 'account'
   }
 
-  constructor(account: string) {
+  constructor(private account: string) {
     this.account = account
   }
 

package/src/subgraph.ts

@@ -4,7 +4,7 @@ import path from 'path'
 import yaml from 'yaml'
 import { strOptions } from 'yaml/types'
 import * as graphql from 'graphql/language'
-import validation from './validation'
+import * as validation from './validation'
 import debug from './debug'
 import { Subgraph as ISubgraph } from './protocols/subgraph'
 

package/src/validation/contract.ts

@@ -1,7 +1,8 @@
 import immutable from 'immutable'
 import Protocol from '../protocols'
+import { ContractCtor } from '../protocols/contract'
 
-export const validateContract = (value: any, ProtocolContract: any) => {
+export const validateContract = (value: string, ProtocolContract: ContractCtor) => {
   const contract = new ProtocolContract(value)
 
   const { valid, error } = contract.validate()
@@ -20,7 +21,7 @@ export const validateContractValues = (
   manifest: immutable.Map<any, any>,
   protocol: Protocol,
 ) => {
-  const ProtocolContract = protocol.getContract()
+  const ProtocolContract = protocol.getContract()!
 
   const fieldName = ProtocolContract.identifierName()
 

package/src/validation/index.ts

@@ -2,9 +2,4 @@ import { validateSchema } from './schema'
 import { validateManifest } from './manifest'
 import { validateContractValues, validateContract } from './contract'
 
-export default {
-  validateSchema,
-  validateManifest,
-  validateContractValues,
-  validateContract,
-}
+export { validateSchema, validateManifest, validateContractValues, validateContract }