@graphprotocol/graph-cli 0.37.3-alpha-20230111115045-e3bcf23 → 0.37.3-alpha-20230111132934-b4190fb

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @graphprotocol/graph-cli
 
-## 0.37.3-alpha-20230111115045-e3bcf23
+## 0.37.3-alpha-20230111132934-b4190fb
 
 ### Patch Changes
 

package/dist/codegen/types/index.js

@@ -9,7 +9,7 @@ const conversions_1 = __importDefault(require("./conversions"));
 // Conversion utilities
 const conversionsForTypeSystems = (fromTypeSystem, toTypeSystem) => {
     let conversions = conversions_1.default.getIn([fromTypeSystem, toTypeSystem]);
-    if (conversions === undefined) {
+    if (conversions == undefined) {
         throw new Error(`Conversions from '${fromTypeSystem}' to '${toTypeSystem}' are not supported`);
     }
     return conversions;
@@ -31,7 +31,7 @@ const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
     let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
     let conversion = conversions.find(conversion => typeof conversion.get(0) === 'string'
         ? conversion.get(0) === fromType
-        : fromType.match(conversion.get(0)));
+        : Boolean(fromType.match(conversion.get(0))));
     if (conversion === undefined) {
         throw new Error(`Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
             `source type '${fromType}' is not supported`);
@@ -42,7 +42,7 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
     let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
     let conversion = conversions.find(conversion => typeof conversion.get(1) === 'string'
         ? conversion.get(1) === toType
-        : toType.match(conversion.get(1)));
+        : Boolean(toType.match(conversion.get(1))));
     if (conversion === undefined) {
         throw new Error(`Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
             `target type '${toType}' is not supported`);
@@ -50,20 +50,26 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
     return objectifyConversion(fromTypeSystem, toTypeSystem, conversion);
 };
 // High-level type system API
-const ascTypeForProtocol = (protocol, protocolType) => findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type']);
+const ascTypeForProtocol = (protocol, protocolType) => findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn([
+    'to',
+    'type',
+]);
 exports.ascTypeForProtocol = ascTypeForProtocol;
 // TODO: this can be removed/replaced by the function above
-const ascTypeForEthereum = ethereumType => ascTypeForProtocol('ethereum', ethereumType);
+const ascTypeForEthereum = (ethereumType) => (0, exports.ascTypeForProtocol)('ethereum', ethereumType);
 exports.ascTypeForEthereum = ascTypeForEthereum;
-const ethereumTypeForAsc = ascType => findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type']);
+const ethereumTypeForAsc = (ascType) => findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn([
+    'to',
+    'type',
+]);
 exports.ethereumTypeForAsc = ethereumTypeForAsc;
 const ethereumToAsc = (code, ethereumType, internalType) => findConversionFromType('ethereum', 'AssemblyScript', ethereumType).get('convert')(code, internalType);
 exports.ethereumToAsc = ethereumToAsc;
 const ethereumFromAsc = (code, ethereumType) => findConversionToType('AssemblyScript', 'ethereum', ethereumType).get('convert')(code);
 exports.ethereumFromAsc = ethereumFromAsc;
-const ascTypeForValue = valueType => findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type']);
+const ascTypeForValue = (valueType) => findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type']);
 exports.ascTypeForValue = ascTypeForValue;
-const valueTypeForAsc = ascType => findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type']);
+const valueTypeForAsc = (ascType) => findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type']);
 exports.valueTypeForAsc = valueTypeForAsc;
 const valueToAsc = (code, valueType) => findConversionFromType('Value', 'AssemblyScript', valueType).get('convert')(code);
 exports.valueToAsc = valueToAsc;

package/dist/scaffold/cosmos.test.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const immutable_1 = __importDefault(require("immutable"));
-const _1 = __importDefault(require("./"));
+const index_1 = __importDefault(require("./index"));
 const protocols_1 = __importDefault(require("../protocols"));
 const protocol = new protocols_1.default('cosmos');
 const scaffoldOptions = {
@@ -12,7 +11,7 @@ const scaffoldOptions = {
     network: 'cosmoshub-4',
     contractName: 'CosmosHub',
 };
-const scaffold = new _1.default(scaffoldOptions);
+const scaffold = new index_1.default(scaffoldOptions);
 describe('Cosmos subgraph scaffolding', () => {
     test('Manifest', () => {
         expect(scaffold.generateManifest()).toEqual(`\

package/dist/scaffold/ethereum.test.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const abi_1 = __importDefault(require("../protocols/ethereum/abi"));
 const immutable_1 = __importDefault(require("immutable"));
-const _1 = __importDefault(require("./"));
+const index_1 = __importDefault(require("./index"));
 const protocols_1 = __importDefault(require("../protocols"));
 const TEST_EVENT = {
     name: 'ExampleEvent',
@@ -72,8 +72,8 @@ const scaffoldOptions = {
     network: 'kovan',
     contractName: 'Contract',
 };
-const scaffold = new _1.default(scaffoldOptions);
-const scaffoldWithIndexEvents = new _1.default({
+const scaffold = new index_1.default(scaffoldOptions);
+const scaffoldWithIndexEvents = new index_1.default({
     ...scaffoldOptions,
     indexEvents: true,
 });
@@ -248,8 +248,8 @@ export function handleExampleEvent1(event: ExampleEvent1Event): void {
     });
     test('Test Files (default)', () => {
         const files = scaffoldWithIndexEvents.generateTests();
-        const testFile = files['contract.test.ts'];
-        const utilsFile = files['contract-utils.ts'];
+        const testFile = files?.['contract.test.ts'];
+        const utilsFile = files?.['contract-utils.ts'];
         expect(testFile).toEqual(`\
 import {
   assert,
@@ -376,8 +376,8 @@ export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
     });
     test('Test Files (for indexing events)', () => {
         const files = scaffoldWithIndexEvents.generateTests();
-        const testFile = files['contract.test.ts'];
-        const utilsFile = files['contract-utils.ts'];
+        const testFile = files?.['contract.test.ts'];
+        const utilsFile = files?.['contract-utils.ts'];
         expect(testFile).toEqual(`\
 import {
   assert,

package/dist/scaffold/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const prettier_1 = __importDefault(require("prettier"));
-const pkginfo = require('pkginfo')(module);
 const gluegun_1 = require("gluegun");
 const GRAPH_CLI_VERSION = process.env.GRAPH_CLI_TESTS
     ? // JSON.stringify should remove this key, we will install the local
@@ -17,7 +16,15 @@ const mapping_1 = require("./mapping");
 const tests_1 = require("./tests");
 const subgraph_1 = require("../command-helpers/subgraph");
 class Scaffold {
-    constructor(options = {}) {
+    protocol;
+    abi;
+    indexEvents;
+    contract;
+    network;
+    contractName;
+    subgraphName;
+    node;
+    constructor(options) {
         this.protocol = options.protocol;
         this.abi = options.abi;
         this.indexEvents = options.indexEvents;
@@ -29,7 +36,7 @@ class Scaffold {
     }
     generatePackageJson() {
         return prettier_1.default.format(JSON.stringify({
-            name: (0, subgraph_1.getSubgraphBasename)(this.subgraphName),
+            name: (0, subgraph_1.getSubgraphBasename)(String(this.subgraphName)),
             license: 'UNLICENSED',
             scripts: {
                 codegen: 'graph codegen',
@@ -70,7 +77,9 @@ dataSources:
         const hasEvents = this.protocol.hasEvents();
         const events = hasEvents ? (0, schema_1.abiEvents)(this.abi).toJS() : [];
         return prettier_1.default.format(hasEvents && this.indexEvents
-            ? events.map(event => (0, schema_1.generateEventType)(event, this.protocol.name)).join('\n\n')
+            ? events
+                .map((event) => (0, schema_1.generateEventType)(event, this.protocol.name))
+                .join('\n\n')
             : (0, schema_1.generateExampleEntityType)(this.protocol, events), {
             parser: 'graphql',
         });
@@ -100,7 +109,7 @@ dataSources:
     generateABIs() {
         return this.protocol.hasABIs()
             ? {
-                [`${this.contractName}.json`]: prettier_1.default.format(JSON.stringify(this.abi.data), {
+                [`${this.contractName}.json`]: prettier_1.default.format(JSON.stringify(this.abi?.data), {
                     parser: 'json',
                 }),
             }

package/dist/scaffold/mapping.js

@@ -22,22 +22,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateEventIndexingHandlers = exports.generateEventFieldAssignments = exports.generateFieldAssignments = exports.generateFieldAssignment = void 0;
-const path_1 = __importDefault(require("path"));
 const util = __importStar(require("../codegen/util"));
-const generateFieldAssignment = path => `entity.${path.join('_')} = event.params.${path.join('.')}`;
+const generateFieldAssignment = (path) => `entity.${path.join('_')} = event.params.${path.join('.')}`;
 exports.generateFieldAssignment = generateFieldAssignment;
-const generateFieldAssignments = ({ index, input }) => input.type === 'tuple'
+const generateFieldAssignments = ({ index, input, }) => input.type === 'tuple'
     ? util
         .unrollTuple({ value: input, index, path: [input.name || `param${index}`] })
-        .map(({ path }) => generateFieldAssignment(path))
-    : generateFieldAssignment([input.name || `param${index}`]);
+        .map(({ path }) => (0, exports.generateFieldAssignment)(path))
+    : (0, exports.generateFieldAssignment)([input.name || `param${index}`]);
 exports.generateFieldAssignments = generateFieldAssignments;
-const generateEventFieldAssignments = event => event.inputs.reduce((acc, input, index) => acc.concat(generateFieldAssignments({ input, index })), []);
+const generateEventFieldAssignments = (event) => event.inputs.reduce((acc, input, index) => acc.concat((0, exports.generateFieldAssignments)({ input, index })), []);
 exports.generateEventFieldAssignments = generateEventFieldAssignments;
 const generateEventIndexingHandlers = (events, contractName) => `
   import { ${events.map(event => `${event._alias} as ${event._alias}Event`)}} from '../generated/${contractName}/${contractName}'
@@ -47,7 +43,7 @@ const generateEventIndexingHandlers = (events, contractName) => `
     .map(event => `
   export function handle${event._alias}(event: ${event._alias}Event): void {
     let entity = new ${event._alias}(event.transaction.hash.concatI32(event.logIndex.toI32()))
-    ${generateEventFieldAssignments(event).join('\n')}
+    ${(0, exports.generateEventFieldAssignments)(event).join('\n')}
 
     entity.blockNumber = event.block.number
     entity.blockTimestamp = event.block.timestamp

package/dist/scaffold/near.test.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const immutable_1 = __importDefault(require("immutable"));
-const _1 = __importDefault(require("./"));
+const index_1 = __importDefault(require("./index"));
 const protocols_1 = __importDefault(require("../protocols"));
 const protocol = new protocols_1.default('near');
 const scaffoldOptions = {
@@ -13,7 +12,7 @@ const scaffoldOptions = {
     network: 'near-mainnet',
     contractName: 'Contract',
 };
-const scaffold = new _1.default(scaffoldOptions);
+const scaffold = new index_1.default(scaffoldOptions);
 describe('NEAR subgraph scaffolding', () => {
     test('Manifest', () => {
         expect(scaffold.generateManifest()).toEqual(`\

package/dist/scaffold/schema.js

@@ -26,9 +26,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateExampleEntityType = exports.generateEventType = exports.generateEventFields = exports.generateField = exports.protocolTypeToGraphQL = exports.abiEvents = void 0;
 const types_1 = require("../codegen/types");
 const util = __importStar(require("../codegen/util"));
-const abiEvents = abi => util.disambiguateNames({
-    values: abi.data.filter(item => item.get('type') === 'event'),
-    getName: event => event.get('name'),
+const abiEvents = (abi) => util.disambiguateNames({
+    values: abi.data.filter((item) => item.get('type') === 'event'),
+    getName: (event) => event.get('name'),
     setName: (event, name) => event.set('_alias', name),
 });
 exports.abiEvents = abiEvents;
@@ -37,14 +37,14 @@ const protocolTypeToGraphQL = (protocol, name) => {
     return (0, types_1.valueTypeForAsc)(ascType);
 };
 exports.protocolTypeToGraphQL = protocolTypeToGraphQL;
-const generateField = ({ name, type, protocolName }) => `${name}: ${protocolTypeToGraphQL(protocolName, type)}! # ${type}`;
+const generateField = ({ name, type, protocolName, }) => `${name}: ${(0, exports.protocolTypeToGraphQL)(protocolName, type)}! # ${type}`;
 exports.generateField = generateField;
-const generateEventFields = ({ index, input, protocolName }) => input.type == 'tuple'
+const generateEventFields = ({ index, input, protocolName, }) => input.type == 'tuple'
     ? util
         .unrollTuple({ value: input, path: [input.name || `param${index}`], index })
-        .map(({ path, type }) => generateField({ name: path.join('_'), type, protocolName }))
+        .map(({ path, type }) => (0, exports.generateField)({ name: path.join('_'), type, protocolName }))
     : [
-        generateField({
+        (0, exports.generateField)({
             name: input.name || `param${index}`,
             type: input.type,
             protocolName,
@@ -54,7 +54,7 @@ exports.generateEventFields = generateEventFields;
 const generateEventType = (event, protocolName) => `type ${event._alias} @entity(immutable: true) {
       id: Bytes!
       ${event.inputs
-    .reduce((acc, input, index) => acc.concat(generateEventFields({ input, index, protocolName })), [])
+    .reduce((acc, input, index) => acc.concat((0, exports.generateEventFields)({ input, index, protocolName })), [])
     .join('\n')}
       blockNumber: BigInt!
       blockTimestamp: BigInt!
@@ -67,7 +67,7 @@ const generateExampleEntityType = (protocol, events) => {
   id: Bytes!
   count: BigInt!
   ${events[0].inputs
-            .reduce((acc, input, index) => acc.concat(generateEventFields({ input, index, protocolName: protocol.name })), [])
+            .reduce((acc, input, index) => acc.concat((0, exports.generateEventFields)({ input, index, protocolName: protocol.name })), [])
             .slice(0, 2)
             .join('\n')}
 }`;

package/dist/scaffold/tests.js

@@ -17,11 +17,11 @@ const VARIABLES_VALUES = {
 };
 const generateTestsFiles = (contract, events, indexEvents) => {
     const eventsTypes = events
-        .flatMap(event => event.inputs.map(input => {
+        .flatMap(event => event.inputs.map((input) => {
         // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
         // If we don't do that we may miss a type that should be imported from graph-ts
         const ascType = (0, types_1.ascTypeForEthereum)(input.type);
-        const inner = fetchArrayInnerType(ascType);
+        const inner = fetchArrayInnerType(String(ascType));
         return inner ? inner[1] : ascType;
     }))
         .filter(type => !type.startsWith('ethereum.') && !isNativeType(type));
@@ -39,16 +39,16 @@ exports.generateTestsFiles = generateTestsFiles;
   let displayName = "Example string value"
   let imageUrl = "Example string value"
 */
-const generateArguments = eventInputs => {
+const generateArguments = (eventInputs) => {
     return eventInputs
         .map((input, index) => {
         let ascType = (0, types_1.ascTypeForEthereum)(input.type);
-        return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`;
+        return `let ${input.name || `param${index}`} = ${assignValue(ascType)}`;
     })
         .join('\n');
 };
 // Generates the value that will be assigned to a variable in generateArguments()
-const assignValue = type => {
+const assignValue = (type) => {
     switch (type) {
         case 'string':
             return `"${VARIABLES_VALUES[type]}"`;
@@ -85,7 +85,7 @@ const generateFieldsAssertions = (entity, eventInputs, indexEvents) => eventInpu
   )`)
     .join('\n');
 // Returns the expected value for a given type in generateFieldsAssertions()
-const expectedValue = type => {
+const expectedValue = (type) => {
     switch (type) {
         case fetchArrayInnerType(type)?.input:
             const innerType = fetchArrayInnerType(type)[1];
@@ -96,11 +96,11 @@ const expectedValue = type => {
     }
 };
 // Checks if the type is a native AS type or should be imported from graph-ts
-const isNativeType = type => {
+const isNativeType = (type) => {
     let natives = [/i32/, /string/, /boolean/];
     return natives.some(rx => rx.test(type));
 };
-const fetchArrayInnerType = type => type.match(/Array<(.*?)>/);
+const fetchArrayInnerType = (type) => type.match(/Array<(.*?)>/);
 // Generates the example test.ts file
 const generateExampleTest = (contract, event, indexEvents, importTypes) => {
     const entity = indexEvents ? `${event._alias}` : 'ExampleEntity';
@@ -156,11 +156,12 @@ const generateTestHelper = (contract, events, importTypes) => {
 
   ${generateMockedEvents(events).join('\n')}`;
 };
-const generateMockedEvents = events => events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), []);
-const generateMockedEvent = event => {
+const generateMockedEvents = (events) => events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), []);
+const generateMockedEvent = (event) => {
     const varName = `${gluegun_1.strings.camelCase(event._alias)}Event`;
     const fnArgs = event.inputs.map((input, index) => `${input.name || `param${index}`}: ${(0, types_1.ascTypeForEthereum)(input.type)}`);
-    const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name || `param${index}`}", ${(0, types_1.ethereumFromAsc)(input.name || `param${index}`, input.type)}))`);
+    const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name ||
+        `param${index}`}", ${(0, types_1.ethereumFromAsc)(input.name || `param${index}`, input.type)}))`);
     return `
     export function create${event._alias}Event(${fnArgs.join(', ')}): ${event._alias} {
       let ${varName} = changetype<${event._alias}>(newMockEvent());

package/package.json

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

package/src/codegen/types/{index.js → index.ts}

@@ -4,17 +4,21 @@ import TYPE_CONVERSIONS from './conversions'
 
 // Conversion utilities
 
-const conversionsForTypeSystems = (fromTypeSystem, toTypeSystem) => {
+const conversionsForTypeSystems = (fromTypeSystem: string, toTypeSystem: string) => {
   let conversions = TYPE_CONVERSIONS.getIn([fromTypeSystem, toTypeSystem])
-  if (conversions === undefined) {
+  if (conversions == undefined) {
     throw new Error(
       `Conversions from '${fromTypeSystem}' to '${toTypeSystem}' are not supported`,
     )
   }
-  return conversions
+  return conversions as immutable.Collection<any, any>
 }
 
-const objectifyConversion = (fromTypeSystem, toTypeSystem, conversion) => {
+const objectifyConversion = (
+  fromTypeSystem: string,
+  toTypeSystem: string,
+  conversion: immutable.Collection<any, any>,
+) => {
   return immutable.fromJS({
     from: {
       typeSystem: fromTypeSystem,
@@ -28,13 +32,17 @@ const objectifyConversion = (fromTypeSystem, toTypeSystem, conversion) => {
   })
 }
 
-const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
+const findConversionFromType = (
+  fromTypeSystem: string,
+  toTypeSystem: string,
+  fromType: string,
+): immutable.Collection<any, any> => {
   let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
 
   let conversion = conversions.find(conversion =>
     typeof conversion.get(0) === 'string'
       ? conversion.get(0) === fromType
-      : fromType.match(conversion.get(0)),
+      : Boolean(fromType.match(conversion.get(0))),
   )
 
   if (conversion === undefined) {
@@ -47,13 +55,17 @@ const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
   return objectifyConversion(fromTypeSystem, toTypeSystem, conversion)
 }
 
-const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
+const findConversionToType = (
+  fromTypeSystem: string,
+  toTypeSystem: string,
+  toType: string,
+): immutable.Collection<any, any> => {
   let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
 
   let conversion = conversions.find(conversion =>
     typeof conversion.get(1) === 'string'
       ? conversion.get(1) === toType
-      : toType.match(conversion.get(1)),
+      : Boolean(toType.match(conversion.get(1))),
   )
 
   if (conversion === undefined) {
@@ -68,47 +80,43 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
 
 // High-level type system API
 
-const ascTypeForProtocol = (protocol, protocolType) =>
-  findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type'])
+export const ascTypeForProtocol = (protocol: string, protocolType: string) =>
+  findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn([
+    'to',
+    'type',
+  ]) as string
 
 // TODO: this can be removed/replaced by the function above
-const ascTypeForEthereum = ethereumType => ascTypeForProtocol('ethereum', ethereumType)
-
-const ethereumTypeForAsc = ascType =>
-  findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type'])
-
-const ethereumToAsc = (code, ethereumType, internalType) =>
+export const ascTypeForEthereum = (ethereumType: string) =>
+  ascTypeForProtocol('ethereum', ethereumType)
+
+export const ethereumTypeForAsc = (ascType: string) =>
+  findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn([
+    'to',
+    'type',
+  ]) as string
+
+export const ethereumToAsc = (
+  code: string,
+  ethereumType: string,
+  internalType?: string,
+) =>
   findConversionFromType('ethereum', 'AssemblyScript', ethereumType).get('convert')(
     code,
     internalType,
   )
 
-const ethereumFromAsc = (code, ethereumType) =>
+export const ethereumFromAsc = (code: string, ethereumType: string) =>
   findConversionToType('AssemblyScript', 'ethereum', ethereumType).get('convert')(code)
 
-const ascTypeForValue = valueType =>
+export const ascTypeForValue = (valueType: string) =>
   findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type'])
 
-const valueTypeForAsc = ascType =>
+export const valueTypeForAsc = (ascType: string) =>
   findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type'])
 
-const valueToAsc = (code, valueType) =>
+export const valueToAsc = (code: string, valueType: string) =>
   findConversionFromType('Value', 'AssemblyScript', valueType).get('convert')(code)
 
-const valueFromAsc = (code, valueType) =>
+export const valueFromAsc = (code: string, valueType: string) =>
   findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code)
-
-export {
-  // protocol <-> AssemblyScript
-  ascTypeForProtocol,
-  // ethereum <-> AssemblyScript
-  ascTypeForEthereum,
-  ethereumTypeForAsc,
-  ethereumToAsc,
-  ethereumFromAsc,
-  // Value <-> AssemblyScript
-  ascTypeForValue,
-  valueTypeForAsc,
-  valueToAsc,
-  valueFromAsc,
-}

package/src/scaffold/{cosmos.test.js → cosmos.test.ts}

@@ -1,5 +1,4 @@
-import immutable from 'immutable'
-import Scaffold from './'
+import Scaffold from './index'
 import Protocol from '../protocols'
 
 const protocol = new Protocol('cosmos')

package/src/scaffold/{ethereum.test.js → ethereum.test.ts}

@@ -1,6 +1,6 @@
 import ABI from '../protocols/ethereum/abi'
 import immutable from 'immutable'
-import Scaffold from './'
+import Scaffold from './index'
 import Protocol from '../protocols'
 
 const TEST_EVENT = {
@@ -262,8 +262,8 @@ export function handleExampleEvent1(event: ExampleEvent1Event): void {
 
   test('Test Files (default)', () => {
     const files = scaffoldWithIndexEvents.generateTests()
-    const testFile = files['contract.test.ts']
-    const utilsFile = files['contract-utils.ts']
+    const testFile = files?.['contract.test.ts']
+    const utilsFile = files?.['contract-utils.ts']
     expect(testFile).toEqual(`\
 import {
   assert,
@@ -391,8 +391,8 @@ export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
 
   test('Test Files (for indexing events)', () => {
     const files = scaffoldWithIndexEvents.generateTests()
-    const testFile = files['contract.test.ts']
-    const utilsFile = files['contract-utils.ts']
+    const testFile = files?.['contract.test.ts']
+    const utilsFile = files?.['contract-utils.ts']
 
     expect(testFile).toEqual(`\
 import {

package/src/scaffold/{index.js → index.ts}

@@ -1,5 +1,4 @@
 import prettier from 'prettier'
-const pkginfo = require('pkginfo')(module)
 import { strings } from 'gluegun'
 
 const GRAPH_CLI_VERSION = process.env.GRAPH_CLI_TESTS
@@ -12,10 +11,32 @@ const GRAPH_CLI_VERSION = process.env.GRAPH_CLI_TESTS
 import { abiEvents, generateEventType, generateExampleEntityType } from './schema'
 import { generateEventIndexingHandlers } from './mapping'
 import { generateTestsFiles } from './tests'
+import Protocol from '../protocols'
 import { getSubgraphBasename } from '../command-helpers/subgraph'
+import ABI from '../protocols/ethereum/abi'
+
+export interface ScaffoldOptions {
+  protocol: Protocol
+  abi?: ABI
+  indexEvents?: boolean
+  contract?: string
+  network: string
+  contractName: string
+  subgraphName?: string
+  node?: string
+}
 
 export default class Scaffold {
-  constructor(options = {}) {
+  protocol: Protocol
+  abi?: ABI
+  indexEvents?: boolean
+  contract?: string
+  network: string
+  contractName: string
+  subgraphName?: string
+  node?: string
+
+  constructor(options: ScaffoldOptions) {
     this.protocol = options.protocol
     this.abi = options.abi
     this.indexEvents = options.indexEvents
@@ -29,7 +50,7 @@ export default class Scaffold {
   generatePackageJson() {
     return prettier.format(
       JSON.stringify({
-        name: getSubgraphBasename(this.subgraphName),
+        name: getSubgraphBasename(String(this.subgraphName)),
         license: 'UNLICENSED',
         scripts: {
           codegen: 'graph codegen',
@@ -81,7 +102,9 @@ dataSources:
 
     return prettier.format(
       hasEvents && this.indexEvents
-        ? events.map(event => generateEventType(event, this.protocol.name)).join('\n\n')
+        ? events
+            .map((event: any) => generateEventType(event, this.protocol.name))
+            .join('\n\n')
         : generateExampleEntityType(this.protocol, events),
       {
         parser: 'graphql',
@@ -124,7 +147,7 @@ dataSources:
   generateABIs() {
     return this.protocol.hasABIs()
       ? {
-          [`${this.contractName}.json`]: prettier.format(JSON.stringify(this.abi.data), {
+          [`${this.contractName}.json`]: prettier.format(JSON.stringify(this.abi?.data), {
             parser: 'json',
           }),
         }

package/src/scaffold/{mapping.js → mapping.ts}

@@ -1,24 +1,29 @@
-import path from 'path'
-
 import * as util from '../codegen/util'
 
-const generateFieldAssignment = path =>
+export const generateFieldAssignment = (path: string[]) =>
   `entity.${path.join('_')} = event.params.${path.join('.')}`
 
-const generateFieldAssignments = ({ index, input }) =>
+export const generateFieldAssignments = ({
+  index,
+  input,
+}: {
+  index: number
+  input: any
+}) =>
   input.type === 'tuple'
     ? util
         .unrollTuple({ value: input, index, path: [input.name || `param${index}`] })
-        .map(({ path }) => generateFieldAssignment(path))
+        .map(({ path }: any) => generateFieldAssignment(path))
     : generateFieldAssignment([input.name || `param${index}`])
 
-const generateEventFieldAssignments = event =>
+export const generateEventFieldAssignments = (event: any) =>
   event.inputs.reduce(
-    (acc, input, index) => acc.concat(generateFieldAssignments({ input, index })),
+    (acc: any[], input: any, index: number) =>
+      acc.concat(generateFieldAssignments({ input, index })),
     [],
   )
 
-const generateEventIndexingHandlers = (events, contractName) =>
+export const generateEventIndexingHandlers = (events: any[], contractName: string) =>
   `
   import { ${events.map(
     event => `${event._alias} as ${event._alias}Event`,
@@ -45,10 +50,3 @@ const generateEventIndexingHandlers = (events, contractName) =>
     )
     .join('\n')}
 `
-
-export {
-  generateFieldAssignment,
-  generateFieldAssignments,
-  generateEventFieldAssignments,
-  generateEventIndexingHandlers,
-}

package/src/scaffold/{near.test.js → near.test.ts}

@@ -1,5 +1,4 @@
-import immutable from 'immutable'
-import Scaffold from './'
+import Scaffold from './index'
 import Protocol from '../protocols'
 
 const protocol = new Protocol('near')

package/src/scaffold/{schema.js → schema.ts}

@@ -1,26 +1,42 @@
 import { ascTypeForProtocol, valueTypeForAsc } from '../codegen/types'
 import * as util from '../codegen/util'
+import Protocol from '../protocols'
 
-const abiEvents = abi =>
+export const abiEvents = (abi: any) =>
   util.disambiguateNames({
-    values: abi.data.filter(item => item.get('type') === 'event'),
-    getName: event => event.get('name'),
-    setName: (event, name) => event.set('_alias', name),
+    values: abi.data.filter((item: any) => item.get('type') === 'event'),
+    getName: (event: any) => event.get('name'),
+    setName: (event: any, name: string) => event.set('_alias', name),
   })
 
-const protocolTypeToGraphQL = (protocol, name) => {
+export const protocolTypeToGraphQL = (protocol: string, name: string) => {
   let ascType = ascTypeForProtocol(protocol, name)
   return valueTypeForAsc(ascType)
 }
 
-const generateField = ({ name, type, protocolName }) =>
-  `${name}: ${protocolTypeToGraphQL(protocolName, type)}! # ${type}`
+export const generateField = ({
+  name,
+  type,
+  protocolName,
+}: {
+  name: string
+  type: string
+  protocolName: string
+}) => `${name}: ${protocolTypeToGraphQL(protocolName, type)}! # ${type}`
 
-const generateEventFields = ({ index, input, protocolName }) =>
+export const generateEventFields = ({
+  index,
+  input,
+  protocolName,
+}: {
+  index: number
+  input: any
+  protocolName: string
+}) =>
   input.type == 'tuple'
     ? util
         .unrollTuple({ value: input, path: [input.name || `param${index}`], index })
-        .map(({ path, type }) =>
+        .map(({ path, type }: any) =>
           generateField({ name: path.join('_'), type, protocolName }),
         )
     : [
@@ -31,13 +47,13 @@ const generateEventFields = ({ index, input, protocolName }) =>
         }),
       ]
 
-const generateEventType = (event, protocolName) => `type ${
+export const generateEventType = (event: any, protocolName: string) => `type ${
   event._alias
 } @entity(immutable: true) {
       id: Bytes!
       ${event.inputs
         .reduce(
-          (acc, input, index) =>
+          (acc: any[], input: any, index: number) =>
             acc.concat(generateEventFields({ input, index, protocolName })),
           [],
         )
@@ -47,14 +63,14 @@ const generateEventType = (event, protocolName) => `type ${
       transactionHash: Bytes!
     }`
 
-const generateExampleEntityType = (protocol, events) => {
+export const generateExampleEntityType = (protocol: Protocol, events: any[]) => {
   if (protocol.hasABIs() && events.length > 0) {
     return `type ExampleEntity @entity {
   id: Bytes!
   count: BigInt!
   ${events[0].inputs
     .reduce(
-      (acc, input, index) =>
+      (acc: any[], input: any, index: number) =>
         acc.concat(generateEventFields({ input, index, protocolName: protocol.name })),
       [],
     )
@@ -69,12 +85,3 @@ const generateExampleEntityType = (protocol, events) => {
 }`
   }
 }
-
-export {
-  abiEvents,
-  protocolTypeToGraphQL,
-  generateField,
-  generateEventFields,
-  generateEventType,
-  generateExampleEntityType,
-}

package/src/scaffold/{tests.js → tests.ts}

@@ -11,14 +11,18 @@ const VARIABLES_VALUES = {
   bool: true,
 }
 
-const generateTestsFiles = (contract, events, indexEvents) => {
+export const generateTestsFiles = (
+  contract: any,
+  events: any[],
+  indexEvents?: boolean,
+) => {
   const eventsTypes = events
     .flatMap(event =>
-      event.inputs.map(input => {
+      event.inputs.map((input: any) => {
         // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
         // If we don't do that we may miss a type that should be imported from graph-ts
         const ascType = ascTypeForEthereum(input.type)
-        const inner = fetchArrayInnerType(ascType)
+        const inner = fetchArrayInnerType(String(ascType))
         return inner ? inner[1] : ascType
       }),
     )
@@ -44,17 +48,17 @@ const generateTestsFiles = (contract, events, indexEvents) => {
   let displayName = "Example string value"
   let imageUrl = "Example string value"
 */
-const generateArguments = eventInputs => {
+const generateArguments = (eventInputs: any[]) => {
   return eventInputs
     .map((input, index) => {
       let ascType = ascTypeForEthereum(input.type)
-      return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`
+      return `let ${input.name || `param${index}`} = ${assignValue(ascType)}`
     })
     .join('\n')
 }
 
 // Generates the value that will be assigned to a variable in generateArguments()
-const assignValue = type => {
+const assignValue = (type: string): string | number | boolean => {
   switch (type) {
     case 'string':
       return `"${VARIABLES_VALUES[type]}"`
@@ -65,10 +69,10 @@ const assignValue = type => {
     case 'Bytes':
       return `Bytes.fromI32(${VARIABLES_VALUES[type]})`
     case fetchArrayInnerType(type)?.input:
-      const innerType = fetchArrayInnerType(type)[1]
+      const innerType = fetchArrayInnerType(type)![1]
       return `[${assignValue(innerType)}]`
     default:
-      let value = VARIABLES_VALUES[type]
+      let value = VARIABLES_VALUES[type as keyof typeof VARIABLES_VALUES]
       return value ? value : `"${type} Not implemented"`
   }
 }
@@ -82,7 +86,11 @@ const assignValue = type => {
     "0x0000000000000000000000000000000000000001"
   )
 */
-const generateFieldsAssertions = (entity, eventInputs, indexEvents) =>
+const generateFieldsAssertions = (
+  entity: string,
+  eventInputs: any[],
+  indexEvents?: boolean,
+) =>
   eventInputs
     .filter(input => input.name != 'id')
     .map(
@@ -97,28 +105,33 @@ const generateFieldsAssertions = (entity, eventInputs, indexEvents) =>
     .join('\n')
 
 // Returns the expected value for a given type in generateFieldsAssertions()
-const expectedValue = type => {
+const expectedValue = (type: string): string | number | boolean => {
   switch (type) {
     case fetchArrayInnerType(type)?.input:
-      const innerType = fetchArrayInnerType(type)[1]
+      const innerType = fetchArrayInnerType(type)![1]
       return `[${expectedValue(innerType)}]`
     default:
-      let value = VARIABLES_VALUES[type]
+      let value = VARIABLES_VALUES[type as keyof typeof VARIABLES_VALUES]
       return value ? value : `${type} Not implemented`
   }
 }
 
 // Checks if the type is a native AS type or should be imported from graph-ts
-const isNativeType = type => {
+const isNativeType = (type: string) => {
   let natives = [/i32/, /string/, /boolean/]
 
   return natives.some(rx => rx.test(type))
 }
 
-const fetchArrayInnerType = type => type.match(/Array<(.*?)>/)
+const fetchArrayInnerType = (type: string) => type.match(/Array<(.*?)>/)
 
 // Generates the example test.ts file
-const generateExampleTest = (contract, event, indexEvents, importTypes) => {
+const generateExampleTest = (
+  contract: string,
+  event: any,
+  indexEvents?: boolean,
+  importTypes?: string,
+) => {
   const entity = indexEvents ? `${event._alias}` : 'ExampleEntity'
   const eventInputs = event.inputs
   const eventName = event._alias
@@ -141,7 +154,7 @@ const generateExampleTest = (contract, event, indexEvents, importTypes) => {
     beforeAll(() => {
       ${generateArguments(eventInputs)}
       let new${eventName}Event = create${eventName}Event(${eventInputs
-    .map((input, index) => input.name || `param${index}`)
+    .map((input: any, index: number) => input.name || `param${index}`)
     .join(', ')});
       handle${eventName}(new${eventName}Event)
     })
@@ -167,7 +180,7 @@ const generateExampleTest = (contract, event, indexEvents, importTypes) => {
 }
 
 // Generates the utils helper file
-const generateTestHelper = (contract, events, importTypes) => {
+const generateTestHelper = (contract: string, events: any[], importTypes: string) => {
   const eventsNames = events.map(event => event._alias)
 
   return `
@@ -178,20 +191,22 @@ const generateTestHelper = (contract, events, importTypes) => {
   ${generateMockedEvents(events).join('\n')}`
 }
 
-const generateMockedEvents = events =>
+const generateMockedEvents = (events: any[]) =>
   events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), [])
 
-const generateMockedEvent = event => {
+const generateMockedEvent = (event: any) => {
   const varName = `${strings.camelCase(event._alias)}Event`
   const fnArgs = event.inputs.map(
-    (input, index) =>
+    (input: any, index: number) =>
       `${input.name || `param${index}`}: ${ascTypeForEthereum(input.type)}`,
   )
   const ascToEth = event.inputs.map(
-    (input, index) =>
-      `${varName}.parameters.push(new ethereum.EventParam("${
-        input.name || `param${index}`
-      }", ${ethereumFromAsc(input.name || `param${index}`, input.type)}))`,
+    (input: any, index: number) =>
+      `${varName}.parameters.push(new ethereum.EventParam("${input.name ||
+        `param${index}`}", ${ethereumFromAsc(
+        input.name || `param${index}`,
+        input.type,
+      )}))`,
   )
 
   return `
@@ -206,5 +221,3 @@ const generateMockedEvent = event => {
     }
   `
 }
-
-export { generateTestsFiles }