@graphprotocol/graph-cli 0.32.0 → 0.34.0-alpha.0

package/src/codegen/types/index.test.js

@@ -191,6 +191,171 @@ describe('ethereum.Value -> AssemblyScript', () => {
     expect(codegen.ascTypeForEthereum('string[4]')).toBe('Array<string>')
     expect(codegen.ascTypeForEthereum('string[754]')).toBe('Array<string>')
   })
+
+  // Multi dimensional arrays
+
+  test('address[*][*] -> Array<Array<Address>>', () => {
+    expect(codegen.ethereumToAsc('x', 'address[][]')).toBe('x.toAddressMatrix()')
+    expect(codegen.ethereumToAsc('x', 'address[5][]')).toBe('x.toAddressMatrix()')
+    expect(codegen.ethereumToAsc('x', 'address[][4]')).toBe('x.toAddressMatrix()')
+    expect(codegen.ethereumToAsc('x', 'address[1][2]')).toBe('x.toAddressMatrix()')
+    expect(codegen.ethereumToAsc('x', 'address[123][321]')).toBe('x.toAddressMatrix()')
+
+    expect(codegen.ascTypeForEthereum('address[][]')).toBe('Array<Array<Address>>')
+    expect(codegen.ascTypeForEthereum('address[5][]')).toBe('Array<Array<Address>>')
+    expect(codegen.ascTypeForEthereum('address[][4]')).toBe('Array<Array<Address>>')
+    expect(codegen.ascTypeForEthereum('address[1][2]')).toBe('Array<Array<Address>>')
+    expect(codegen.ascTypeForEthereum('address[123][321]')).toBe('Array<Array<Address>>')
+  })
+
+  test('bool[*][*] -> Array<Array<boolean>>', () => {
+    expect(codegen.ethereumToAsc('x', 'bool[][]')).toBe('x.toBooleanMatrix()')
+    expect(codegen.ethereumToAsc('x', 'bool[1][]')).toBe('x.toBooleanMatrix()')
+    expect(codegen.ethereumToAsc('x', 'bool[][3]')).toBe('x.toBooleanMatrix()')
+    expect(codegen.ethereumToAsc('x', 'bool[5][2]')).toBe('x.toBooleanMatrix()')
+    expect(codegen.ethereumToAsc('x', 'bool[275][572]')).toBe('x.toBooleanMatrix()')
+
+    expect(codegen.ascTypeForEthereum('bool[][]')).toBe('Array<Array<boolean>>')
+    expect(codegen.ascTypeForEthereum('bool[1][]')).toBe('Array<Array<boolean>>')
+    expect(codegen.ascTypeForEthereum('bool[][3]')).toBe('Array<Array<boolean>>')
+    expect(codegen.ascTypeForEthereum('bool[5][2]')).toBe('Array<Array<boolean>>')
+    expect(codegen.ascTypeForEthereum('bool[275][572]')).toBe('Array<Array<boolean>>')
+  })
+
+  test('byte[*][*] -> Array<Array<Bytes>>', () => {
+    expect(codegen.ethereumToAsc('x', 'byte[][]')).toBe('x.toBytesMatrix()')
+    expect(codegen.ethereumToAsc('x', 'byte[7][]')).toBe('x.toBytesMatrix()')
+    expect(codegen.ethereumToAsc('x', 'byte[][8]')).toBe('x.toBytesMatrix()')
+    expect(codegen.ethereumToAsc('x', 'byte[553][355]')).toBe('x.toBytesMatrix()')
+
+    expect(codegen.ascTypeForEthereum('byte[][]')).toBe('Array<Array<Bytes>>')
+    expect(codegen.ascTypeForEthereum('byte[7][]')).toBe('Array<Array<Bytes>>')
+    expect(codegen.ascTypeForEthereum('byte[][8]')).toBe('Array<Array<Bytes>>')
+    expect(codegen.ascTypeForEthereum('byte[553][355]')).toBe('Array<Array<Bytes>>')
+  })
+
+  test('bytes[*][*] -> Array<Array<Bytes>>', () => {
+    expect(codegen.ethereumToAsc('x', 'bytes[][]')).toBe('x.toBytesMatrix()')
+    expect(codegen.ethereumToAsc('x', 'bytes[14][]')).toBe('x.toBytesMatrix()')
+    expect(codegen.ethereumToAsc('x', 'bytes[][41]')).toBe('x.toBytesMatrix()')
+    expect(codegen.ethereumToAsc('x', 'bytes[444][555]')).toBe('x.toBytesMatrix()')
+
+    expect(codegen.ascTypeForEthereum('bytes[][]')).toBe('Array<Array<Bytes>>')
+    expect(codegen.ascTypeForEthereum('bytes[14][]')).toBe('Array<Array<Bytes>>')
+    expect(codegen.ascTypeForEthereum('bytes[][41]')).toBe('Array<Array<Bytes>>')
+    expect(codegen.ascTypeForEthereum('bytes[444][555]')).toBe('Array<Array<Bytes>>')
+  })
+
+  test('bytes0[*][*] (invalid)', () => {
+    expect(() => codegen.ethereumToAsc('x', 'bytes0[][]')).toThrow()
+    expect(() => codegen.ethereumToAsc('x', 'bytes0[83][]')).toThrow()
+    expect(() => codegen.ethereumToAsc('x', 'bytes0[][83]')).toThrow()
+    expect(() => codegen.ethereumToAsc('x', 'bytes0[123][321]')).toThrow()
+
+    expect(() => codegen.ascTypeForEthereum('bytes0[][]')).toThrow()
+    expect(() => codegen.ascTypeForEthereum('bytes0[83][]')).toThrow()
+    expect(() => codegen.ascTypeForEthereum('bytes0[][83]')).toThrow()
+    expect(() => codegen.ascTypeForEthereum('bytes0[123][321]')).toThrow()
+  })
+
+  test('bytes1..32[*][*] -> Array<Array<Bytes>>', () => {
+    for (let i = 1; i <= 32; i++) {
+      expect(codegen.ethereumToAsc('x', `bytes${i}[][]`)).toBe('x.toBytesMatrix()')
+      expect(codegen.ethereumToAsc('x', `bytes${i}[7][]`)).toBe('x.toBytesMatrix()')
+      expect(codegen.ethereumToAsc('x', `bytes${i}[][7]`)).toBe('x.toBytesMatrix()')
+      expect(codegen.ethereumToAsc('x', `bytes${i}[432][234]`)).toBe('x.toBytesMatrix()')
+
+      expect(codegen.ascTypeForEthereum(`bytes${i}[][]`)).toBe('Array<Array<Bytes>>')
+      expect(codegen.ascTypeForEthereum(`bytes${i}[6][]`)).toBe('Array<Array<Bytes>>')
+      expect(codegen.ascTypeForEthereum(`bytes${i}[][7]`)).toBe('Array<Array<Bytes>>')
+      expect(codegen.ascTypeForEthereum(`bytes${i}[432][234]`)).toBe('Array<Array<Bytes>>')
+    }
+  })
+
+  test('bytes33[*][*] (invalid)', () => {
+    expect(() => codegen.ethereumToAsc('x', 'bytes33[][]')).toThrow()
+    expect(() => codegen.ethereumToAsc('x', 'bytes33[58][]')).toThrow()
+    expect(() => codegen.ethereumToAsc('x', 'bytes33[][85]')).toThrow()
+    expect(() => codegen.ethereumToAsc('x', 'bytes33[394][493]')).toThrow()
+
+    expect(() => codegen.ascTypeForEthereum('bytes33[][]')).toThrow()
+    expect(() => codegen.ascTypeForEthereum('bytes33[58][]')).toThrow()
+    expect(() => codegen.ascTypeForEthereum('bytes33[][85]')).toThrow()
+    expect(() => codegen.ascTypeForEthereum('bytes33[394][493]')).toThrow()
+  })
+
+  test('int8..32[*][*], uint8..24[*][*] -> Array<Array<i32>>', () => {
+    for (let i = 8; i <= 32; i += 8) {
+      expect(codegen.ethereumToAsc('x', `int${i}[][]`)).toBe('x.toI32Matrix()')
+      expect(codegen.ethereumToAsc('x', `int${i}[6][]`)).toBe('x.toI32Matrix()')
+      expect(codegen.ethereumToAsc('x', `int${i}[][6]`)).toBe('x.toI32Matrix()')
+      expect(codegen.ethereumToAsc('x', `int${i}[4638][8364]`)).toBe('x.toI32Matrix()')
+
+      expect(codegen.ascTypeForEthereum(`int${i}[][]`)).toBe('Array<Array<i32>>')
+      expect(codegen.ascTypeForEthereum(`int${i}[6][]`)).toBe('Array<Array<i32>>')
+      expect(codegen.ascTypeForEthereum(`int${i}[][6]`)).toBe('Array<Array<i32>>')
+      expect(codegen.ascTypeForEthereum(`int${i}[4638][8364]`)).toBe('Array<Array<i32>>')
+    }
+    for (let i = 8; i <= 24; i += 8) {
+      expect(codegen.ethereumToAsc('x', `uint${i}[][]`)).toBe('x.toI32Matrix()')
+      expect(codegen.ethereumToAsc('x', `uint${i}[6][]`)).toBe('x.toI32Matrix()')
+      expect(codegen.ethereumToAsc('x', `uint${i}[][6]`)).toBe('x.toI32Matrix()')
+      expect(codegen.ethereumToAsc('x', `uint${i}[593][395]`)).toBe('x.toI32Matrix()')
+
+      expect(codegen.ascTypeForEthereum(`uint${i}[][]`)).toBe('Array<Array<i32>>')
+      expect(codegen.ascTypeForEthereum(`uint${i}[6][]`)).toBe('Array<Array<i32>>')
+      expect(codegen.ascTypeForEthereum(`uint${i}[][6]`)).toBe('Array<Array<i32>>')
+      expect(codegen.ascTypeForEthereum(`uint${i}[593][395]`)).toBe('Array<Array<i32>>')
+    }
+  })
+
+  test('uint32[*][*] -> Array<Array<BigInt>>', () => {
+    expect(codegen.ethereumToAsc('x', `uint32[][]`)).toBe('x.toBigIntMatrix()')
+    expect(codegen.ethereumToAsc('x', `uint32[6][]`)).toBe('x.toBigIntMatrix()')
+    expect(codegen.ethereumToAsc('x', `uint32[][6]`)).toBe('x.toBigIntMatrix()')
+    expect(codegen.ethereumToAsc('x', `uint32[593][395]`)).toBe('x.toBigIntMatrix()')
+
+    expect(codegen.ascTypeForEthereum(`uint32[][]`)).toBe('Array<Array<BigInt>>')
+    expect(codegen.ascTypeForEthereum(`uint32[6][]`)).toBe('Array<Array<BigInt>>')
+    expect(codegen.ascTypeForEthereum(`uint32[][5]`)).toBe('Array<Array<BigInt>>')
+    expect(codegen.ascTypeForEthereum(`uint32[593][395]`)).toBe('Array<Array<BigInt>>')
+  })
+
+  test('(u)int40..256[*][*] -> Array<Array<BigInt>>', () => {
+    for (let i = 40; i <= 256; i += 8) {
+      expect(codegen.ethereumToAsc('x', `int${i}[][]`)).toBe('x.toBigIntMatrix()')
+      expect(codegen.ethereumToAsc('x', `int${i}[7][]`)).toBe('x.toBigIntMatrix()')
+      expect(codegen.ethereumToAsc('x', `int${i}[][7]`)).toBe('x.toBigIntMatrix()')
+      expect(codegen.ethereumToAsc('x', `int${i}[6833][3386]`)).toBe('x.toBigIntMatrix()')
+
+      expect(codegen.ascTypeForEthereum(`int${i}[][]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`int${i}[7][]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`int${i}[][7]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`int${i}[6833][3386]`)).toBe('Array<Array<BigInt>>')
+
+      expect(codegen.ethereumToAsc('x', `uint${i}[][]`)).toBe('x.toBigIntMatrix()')
+      expect(codegen.ethereumToAsc('x', `uint${i}[23][]`)).toBe('x.toBigIntMatrix()')
+      expect(codegen.ethereumToAsc('x', `uint${i}[][32]`)).toBe('x.toBigIntMatrix()')
+      expect(codegen.ethereumToAsc('x', `uint${i}[467][764]`)).toBe('x.toBigIntMatrix()')
+
+      expect(codegen.ascTypeForEthereum(`uint${i}[][]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`uint${i}[23][]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`uint${i}[][32]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`uint${i}[467][764]`)).toBe('Array<Array<BigInt>>')
+    }
+  })
+
+  test('string[*][*] -> Array<Array<string>>', () => {
+    expect(codegen.ethereumToAsc('x', 'string[][]')).toBe('x.toStringMatrix()')
+    expect(codegen.ethereumToAsc('x', 'string[4][]')).toBe('x.toStringMatrix()')
+    expect(codegen.ethereumToAsc('x', 'string[][3]')).toBe('x.toStringMatrix()')
+    expect(codegen.ethereumToAsc('x', 'string[754][457]')).toBe('x.toStringMatrix()')
+
+    expect(codegen.ascTypeForEthereum('string[][]')).toBe('Array<Array<string>>')
+    expect(codegen.ascTypeForEthereum('string[4][]')).toBe('Array<Array<string>>')
+    expect(codegen.ascTypeForEthereum('string[][3]')).toBe('Array<Array<string>>')
+    expect(codegen.ascTypeForEthereum('string[754][457]')).toBe('Array<Array<string>>')
+  })
 })
 
 describe('AssemblyScript -> ethereum.Value', () => {
@@ -409,6 +574,188 @@ describe('AssemblyScript -> ethereum.Value', () => {
       'ethereum.Value.fromStringArray(x)',
     )
   })
+
+  // Multidimensional arrays
+
+  test('Array<Array<Address>> -> address[*][*]', () => {
+    expect(codegen.ethereumFromAsc('x', 'address[][]')).toBe(
+      'ethereum.Value.fromAddressMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'address[1][]')).toBe(
+      'ethereum.Value.fromAddressMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'address[][2]')).toBe(
+      'ethereum.Value.fromAddressMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'address[123][321]')).toBe(
+      'ethereum.Value.fromAddressMatrix(x)',
+    )
+  })
+
+  test('Array<Array<boolean>> -> bool[*][*]', () => {
+    expect(codegen.ethereumFromAsc('x', 'bool[][]')).toBe(
+      'ethereum.Value.fromBooleanMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'bool[5][]')).toBe(
+      'ethereum.Value.fromBooleanMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'bool[][5]')).toBe(
+      'ethereum.Value.fromBooleanMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'bool[275][572]')).toBe(
+      'ethereum.Value.fromBooleanMatrix(x)',
+    )
+  })
+
+  test('Array<Array<Bytes>> -> byte[*][*]', () => {
+    expect(codegen.ethereumFromAsc('x', 'byte[][]')).toBe(
+      'ethereum.Value.fromFixedBytesMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'byte[7][]')).toBe(
+      'ethereum.Value.fromFixedBytesMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'byte[][6]')).toBe(
+      'ethereum.Value.fromFixedBytesMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'byte[553][355]')).toBe(
+      'ethereum.Value.fromFixedBytesMatrix(x)',
+    )
+  })
+
+  test('Array<Array<Bytes>> -> bytes[*][*]', () => {
+    expect(codegen.ethereumFromAsc('x', 'bytes[][]')).toBe(
+      'ethereum.Value.fromBytesMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'bytes[14][]')).toBe(
+      'ethereum.Value.fromBytesMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'bytes[][41]')).toBe(
+      'ethereum.Value.fromBytesMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'bytes[444][333]')).toBe(
+      'ethereum.Value.fromBytesMatrix(x)',
+    )
+  })
+
+  test('bytes0[*][*] (invalid)', () => {
+    expect(() => codegen.ethereumFromAsc('x', 'bytes0[][]')).toThrow()
+    expect(() => codegen.ethereumFromAsc('x', 'bytes0[83][]')).toThrow()
+    expect(() => codegen.ethereumFromAsc('x', 'bytes0[][38]')).toThrow()
+    expect(() => codegen.ethereumFromAsc('x', 'bytes0[123][321]')).toThrow()
+  })
+
+  test('Array<Array<Bytes>> -> bytes1..32[*][*]', () => {
+    for (let i = 1; i <= 32; i++) {
+      expect(codegen.ethereumFromAsc('x', `bytes${i}[][]`)).toBe(
+        'ethereum.Value.fromFixedBytesMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `bytes${i}[7][]`)).toBe(
+        'ethereum.Value.fromFixedBytesMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `bytes${i}[][7]`)).toBe(
+        'ethereum.Value.fromFixedBytesMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `bytes${i}[432][234]`)).toBe(
+        'ethereum.Value.fromFixedBytesMatrix(x)',
+      )
+    }
+  })
+
+  test('bytes33[*][*] (invalid)', () => {
+    expect(() => codegen.ethereumFromAsc('x', 'bytes33[][]')).toThrow()
+    expect(() => codegen.ethereumFromAsc('x', 'bytes33[58][]')).toThrow()
+    expect(() => codegen.ethereumFromAsc('x', 'bytes33[][85]')).toThrow()
+    expect(() => codegen.ethereumFromAsc('x', 'bytes33[394][493]')).toThrow()
+  })
+
+  test('Array<Array<i32>> -> int8..32[*][*], uint8..24[*][*]', () => {
+    for (let i = 8; i <= 32; i += 8) {
+      expect(codegen.ethereumFromAsc('x', `int${i}[][]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `int${i}[6][]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `int${i}[][5]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `int${i}[4638][8364]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+    }
+
+    for (let i = 8; i <= 24; i += 8) {
+      expect(codegen.ethereumFromAsc('x', `uint${i}[][]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `uint${i}[6][]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `uint${i}[][5]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `uint${i}[593][395]`)).toBe(
+        'ethereum.Value.fromI32Matrix(x)',
+      )
+    }
+  })
+
+  test('Array<Array<BigInt>> -> uint32[*][*]', () => {
+    expect(codegen.ethereumFromAsc('x', `uint32[][]`)).toBe(
+      'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', `uint32[6][]`)).toBe(
+      'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', `uint32[][5]`)).toBe(
+      'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', `uint32[593][395]`)).toBe(
+      'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+    )
+  })
+
+  test('Array<Array<BigInt>> -> (u)int40..256[*][*]', () => {
+    for (let i = 40; i <= 256; i += 8) {
+      expect(codegen.ethereumFromAsc('x', `int${i}[][]`)).toBe(
+        'ethereum.Value.fromSignedBigIntMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `int${i}[8][]`)).toBe(
+        'ethereum.Value.fromSignedBigIntMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `int${i}[][7]`)).toBe(
+        'ethereum.Value.fromSignedBigIntMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `int${i}[6833][3386]`)).toBe(
+        'ethereum.Value.fromSignedBigIntMatrix(x)',
+      )
+
+      expect(codegen.ethereumFromAsc('x', `uint${i}[][]`)).toBe(
+        'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `uint${i}[23][]`)).toBe(
+        'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `uint${i}[][32]`)).toBe(
+        'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+      )
+      expect(codegen.ethereumFromAsc('x', `uint${i}[467][764]`)).toBe(
+        'ethereum.Value.fromUnsignedBigIntMatrix(x)',
+      )
+    }
+  })
+
+  test('Array<Array<String>> -> string[*][*]', () => {
+    expect(codegen.ethereumFromAsc('x', 'string[]')).toBe(
+      'ethereum.Value.fromStringArray(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'string[4]')).toBe(
+      'ethereum.Value.fromStringArray(x)',
+    )
+    expect(codegen.ethereumFromAsc('x', 'string[754]')).toBe(
+      'ethereum.Value.fromStringArray(x)',
+    )
+  })
 })
 
 describe('Value -> AssemblyScript', () => {

package/src/command-helpers/abi.js

@@ -60,6 +60,9 @@ const getEtherscanLikeAPIUrl = (network) => {
     case "aurora-testnet": return `https://api-testnet.aurorascan.dev/api`
     case "optimism-kovan": return `https://api-kovan-optimistic.etherscan.io/api`
     case "optimism": return `https://api-optimistic.etherscan.io/api`
+    case "moonbeam": return `https://api-moonbeam.moonscan.io/api`
+    case "moonriver": return `https://api-moonriver.moonscan.io/api`
+    case "mbase": return `https://api-moonbase.moonscan.io/api`
     case "avalanche": return `https://api.snowtrace.io/api`;
     case "fuji": return `https://api-testnet.snowtrace.io/api`;
     default: return `https://api-${network}.etherscan.io/api`

package/src/command-helpers/jsonrpc.js

@@ -3,12 +3,16 @@ const toolbox = require('gluegun/toolbox')
 
 const createJsonRpcClient = url => {
   let params = {
-    auth: url.auth,
     host: url.hostname,
     port: url.port,
     path: url.pathname,
   }
 
+  // username may be empty
+  if (url.password) {
+    params.auth = `${url.username}:${url.password}`
+  }
+
   if (url.protocol === 'https:') {
     return jayson.Client.https(params)
   } else if (url.protocol === 'http:') {

package/src/command-helpers/scaffold.js

@@ -7,10 +7,17 @@ const { step } = require('./spinner')
 const Scaffold = require('../scaffold')
 const { generateEventIndexingHandlers } = require('../scaffold/mapping')
 const { generateEventType, abiEvents } = require('../scaffold/schema')
+const { generateTestsFiles } = require('../scaffold/tests')
 const { strings } = require('gluegun')
 const { Map } = require('immutable')
 
-const generateDataSource = async (protocol, contractName, network, contractAddress, abi) => {
+const generateDataSource = async (
+  protocol,
+  contractName,
+  network,
+  contractAddress,
+  abi,
+) => {
   const protocolManifest = protocol.getManifestScaffold()
 
   return Map.of(
@@ -89,13 +96,13 @@ const writeABI = async (abi, contractName) => {
 
 const writeSchema = async (abi, protocol, schemaPath, entities) => {
   const events = protocol.hasEvents()
-    ? abiEvents(abi).filter(event => entities.indexOf(event.get('name')) === -1).toJS()
+    ? abiEvents(abi)
+        .filter(event => entities.indexOf(event.get('name')) === -1)
+        .toJS()
     : []
 
   let data = prettier.format(
-    events.map(
-        event => generateEventType(event, protocol.name)
-      ).join('\n\n'),
+    events.map(event => generateEventType(event, protocol.name)).join('\n\n'),
     {
       parser: 'graphql',
     },
@@ -106,18 +113,39 @@ const writeSchema = async (abi, protocol, schemaPath, entities) => {
 
 const writeMapping = async (abi, protocol, contractName, entities) => {
   const events = protocol.hasEvents()
-    ? abiEvents(abi).filter(event => entities.indexOf(event.get('name')) === -1).toJS()
+    ? abiEvents(abi)
+        .filter(event => entities.indexOf(event.get('name')) === -1)
+        .toJS()
     : []
 
-  let mapping = prettier.format(
-    generateEventIndexingHandlers(
-        events,
-        contractName,
-      ),
-    { parser: 'typescript', semi: false },
-  )
+  let mapping = prettier.format(generateEventIndexingHandlers(events, contractName), {
+    parser: 'typescript',
+    semi: false,
+  })
+
+  await fs.writeFile(`./src/${strings.kebabCase(contractName)}.ts`, mapping, {
+    encoding: 'utf-8',
+  })
+}
 
-  await fs.writeFile(`./src/${strings.kebabCase(contractName)}.ts`, mapping, { encoding: 'utf-8' })
+const writeTestsFiles = async (abi, protocol, contractName) => {
+  const hasEvents = protocol.hasEvents()
+  const events = hasEvents
+    ? abiEvents(abi).toJS()
+    : []
+
+  if(events.length > 0) {
+    // If a contract is added to a subgraph that has no tests folder
+    await fs.ensureDir('./tests/')
+
+    const testsFiles = generateTestsFiles(contractName, events, true)
+
+    for (const [fileName, content] of Object.entries(testsFiles)) {
+      await fs.writeFile(`./tests/${fileName}`, content, {
+        encoding: 'utf-8',
+      })
+    }
+  }
 }
 
 module.exports = {
@@ -128,4 +156,5 @@ module.exports = {
   writeABI,
   writeSchema,
   writeMapping,
+  writeTestsFiles,
 }

package/src/command-helpers/studio.js

@@ -1,4 +1,4 @@
-const allowedStudioNetworks = ['mainnet', 'rinkeby']
+const allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli']
 
 const validateStudioNetwork = ({ studio, product, network }) => {
   let isStudio = studio || product === 'subgraph-studio'

package/src/commands/add.js

@@ -5,7 +5,7 @@ const { withSpinner } = require('../command-helpers/spinner')
 const Subgraph = require('../subgraph')
 const Protocol = require('../protocols')
 const DataSourcesExtractor = require('../command-helpers/data-sources')
-const { generateDataSource, writeABI, writeSchema, writeMapping } = require('../command-helpers/scaffold')
+const { generateDataSource, writeABI, writeSchema, writeMapping, writeTestsFiles } = require('../command-helpers/scaffold')
 const { loadAbiFromEtherscan, loadAbiFromBlockScout } = require('../command-helpers/abi')
 const EthereumABI = require('../protocols/ethereum/abi')
 const { fixParameters } = require('../command-helpers/gluegun')
@@ -102,6 +102,7 @@ module.exports = {
     await writeABI(ethabi, contractName)
     await writeSchema(ethabi, protocol, result.getIn(['schema', 'file']), collisionEntities)
     await writeMapping(ethabi, protocol, contractName, collisionEntities)
+    await writeTestsFiles(ethabi, protocol, contractName)
 
     let dataSources = result.get('dataSources')
     let dataSource = await generateDataSource(protocol,

package/src/commands/init.js

@@ -827,7 +827,7 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
   if (addContractConfirmation) {
     let abiFromFile
     let ProtocolContract = protocolInstance.getContract()
-  
+
     let questions = [
       {
         type: 'input',
@@ -866,16 +866,16 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
 
     // 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)
-  
+
       if (fs.existsSync(directory)) {
         process.chdir(directory)
       }
-  
+
       let commandLine = ['add', contract, '--contract-name', contractName]
-  
+
       if (abiFromFile) {
         if (abi.includes(directory)) {
           commandLine.push('--abi', path.normalize(abi.replace(directory, '')))
@@ -895,4 +895,4 @@ const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
   }
 
   return addContractConfirmation
-}
+}

package/src/commands/test.js

@@ -168,7 +168,7 @@ async function getPlatform(logsOpt) {
   const type = os.type()
   const arch = os.arch()
   const cpuCore = os.cpus()[0]
-  const isM1 = (arch === 'arm64' && /Apple (M1|processor)/.test(cpuCore.model))
+  const isAppleSilicon = (arch === 'arm64' && /Apple (M1|M2|processor)/.test(cpuCore.model))
   const linuxInfo = type === 'Linux' ? await getLinuxInfo() : {}
   const linuxDistro = linuxInfo.name
   const release = linuxInfo.version || os.release()
@@ -178,13 +178,11 @@ async function getPlatform(logsOpt) {
     print.info(`OS type: ${linuxDistro || type}\nOS arch: ${arch}\nOS release: ${release}\nOS major version: ${majorVersion}\nCPU model: ${cpuCore.model}`)
   }
 
-  if (arch === 'x64' || isM1) {
+  if (arch === 'x64' || isAppleSilicon) {
     if (type === 'Darwin') {
-      if (majorVersion === 19) {
-        return 'binary-macos-10.15'
-      } else if (majorVersion === 18) {
-        return 'binary-macos-10.14'
-      } else if (isM1) {
+      if (majorVersion === 18 || majorVersion === 19) {
+        return 'binary-macos-10.15' // GitHub dropped support for macOS 10.14 in Actions, but it seems 10.15 binary works on 10.14 too
+      } else if (isAppleSilicon) {
         return 'binary-macos-11-m1'
       }
       return 'binary-macos-11'
@@ -196,8 +194,6 @@ async function getPlatform(logsOpt) {
       } else {
         return 'binary-linux-20'
       }
-    } else if (type === 'Windows_NT') {
-      return 'binary-windows'
     }
   }
 

package/src/migrations/mapping_api_version_0_0_4.js

@@ -19,7 +19,7 @@ module.exports = {
       return 'graph-ts dependency not installed yet'
     }
 
-    let manifest = loadManifest(manifestFile)
+    let manifest = await loadManifest(manifestFile)
     return (
       // Only migrate if the graph-ts version is >= 0.22.0...
       // Coerce needed because we may be dealing with an alpha version

package/src/migrations/mapping_api_version_0_0_5.js

@@ -19,7 +19,7 @@ module.exports = {
       return 'graph-ts dependency not installed yet'
     }
 
-    let manifest = loadManifest(manifestFile)
+    let manifest = await loadManifest(manifestFile)
     return (
       // Only migrate if the graph-ts version is >= 0.24.0...
       // Coerce needed because we may be dealing with an alpha version

package/src/protocols/index.js

@@ -42,9 +42,7 @@ module.exports = class Protocol {
       arweave: ['arweave-mainnet'],
       ethereum: [
         'mainnet',
-        'kovan',
         'rinkeby',
-        'ropsten',
         'goerli',
         'poa-core',
         'poa-sokol',
@@ -74,9 +72,11 @@ module.exports = class Protocol {
       near: ['near-mainnet', 'near-testnet'],
       cosmos: [
         'cosmoshub-4',
-        'theta-testnet-001',
+        'theta-testnet-001', // CosmosHub testnet
         'osmosis-1',
-        'osmo-test-4'
+        'osmo-test-4',       // Osmosis testnet
+        'juno-1', 
+        'uni-3'              // Juno testnet
       ],
     })
   }

package/src/protocols/ipfs/codegen/file_template.js

@@ -0,0 +1,40 @@
+const tsCodegen = require('../../../codegen/typescript')
+
+module.exports = class IpfsFileTemplateCodeGen {
+  constructor(template) {
+    this.template = template
+  }
+
+  generateModuleImports() {
+    return []
+  }
+
+  generateCreateMethod() {
+    const name = this.template.get('name')
+
+    return tsCodegen.staticMethod(
+      'create',
+      [tsCodegen.param('cid', tsCodegen.namedType('string'))],
+      tsCodegen.namedType('void'),
+      `
+      DataSourceTemplate.create('${name}', [cid])
+      `,
+    )
+  }
+
+  generateCreateWithContextMethod() {
+    const name = this.template.get('name')
+
+    return tsCodegen.staticMethod(
+      'createWithContext',
+      [
+        tsCodegen.param('cid', tsCodegen.namedType('string')),
+        tsCodegen.param('context', tsCodegen.namedType('DataSourceContext')),
+      ],
+      tsCodegen.namedType('void'),
+      `
+      DataSourceTemplate.createWithContext('${name}', [cid], context)
+      `,
+    )
+  }
+}