@graphprotocol/graph-cli 0.33.1 → 0.34.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/codegen/util.js

@@ -18,13 +18,17 @@ const isTupleType = t => {
 }
 
 const containsTupleType = t => {
-  return isTupleType(t) || isTupleArrayType(t)
+  return isTupleType(t) || isTupleArrayType(t) || isTupleMatrixType(t)
 }
 
 const isTupleArrayType = t => {
   return t.match(/^tuple\[([0-9]+)?\]$/)
 }
 
+const isTupleMatrixType = t => {
+  return t.match(/^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/)
+}
+
 const unrollTuple = ({ path, index, value }) =>
   value.components.reduce((acc, component, index) => {
     let name = component.name || `value${index}`
@@ -44,5 +48,6 @@ module.exports = {
   disambiguateNames,
   isTupleType,
   isTupleArrayType,
+  isTupleMatrixType,
   unrollTuple,
 }

package/src/command-helpers/spinner.js

@@ -28,8 +28,14 @@ const withSpinner = async (text, errorText, warningText, f) => {
   try {
     let result = await f(spinner)
     if (typeof result === 'object') {
+      let hasError = Object.keys(result).indexOf('error') >= 0
       let hasWarning = Object.keys(result).indexOf('warning') >= 0
       let hasResult = Object.keys(result).indexOf('result') >= 0
+
+      if (hasError) {
+        spinner.fail(`${errorText}: ${result.error}`)
+        return hasResult ? result.result : result
+      }
       if (hasWarning && hasResult) {
         if (result.warning !== null) {
           spinner.warn(`${warningText}: ${result.warning}`)

package/src/commands/init.js

@@ -24,6 +24,8 @@ const Protocol = require('../protocols')
 const protocolChoices = Array.from(Protocol.availableProtocols().keys())
 const availableNetworks = Protocol.availableNetworks()
 
+const DEFAULT_EXAMPLE_SUBGRAPH = 'ethereum/gravatar'
+
 const HELP = `
 ${chalk.bold('graph init')} [options] [subgraph-name] [directory]
 
@@ -40,7 +42,7 @@ ${chalk.dim('Options:')}
 ${chalk.dim('Choose mode with one of:')}
 
       --from-contract <contract> Creates a scaffold based on an existing contract
-      --from-example             Creates a scaffold based on an example subgraph
+      --from-example [example]   Creates a scaffold based on an example subgraph
 
 ${chalk.dim('Options for --from-contract:')}
 
@@ -106,7 +108,7 @@ const processInitForm = async (
       message: 'Product for which to initialize',
       choices: ['subgraph-studio', 'hosted-service'],
       skip: () =>
-        protocol === 'near' ||
+        protocol === 'arweave' || protocol === 'cosmos' || protocol === 'near' ||
         product === 'subgraph-studio' ||
         product === 'hosted-service' ||
         studio !== undefined || node !== undefined,
@@ -280,9 +282,6 @@ const loadAbiFromFile = async (ABI, filename) => {
 
 module.exports = {
   description: 'Creates a new subgraph with basic scaffolding',
-  options: {
-    boolean: ['from-example'],
-  },
   run: async toolbox => {
     // Obtain tools
     let { print, system } = toolbox
@@ -317,7 +316,6 @@ module.exports = {
     let subgraphName, directory
     try {
       ;[subgraphName, directory] = fixParameters(toolbox.parameters, {
-        fromExample,
         allowSimpleName,
         help,
         h,
@@ -368,7 +366,7 @@ module.exports = {
     if (fromExample && subgraphName && directory) {
       return await initSubgraphFromExample(
         toolbox,
-        { allowSimpleName, directory, subgraphName, studio, product },
+        { fromExample, allowSimpleName, directory, subgraphName, studio, product },
         { commands },
       )
     }
@@ -455,6 +453,7 @@ module.exports = {
       await initSubgraphFromExample(
         toolbox,
         {
+          fromExample: fromExample,
           subgraphName: inputs.subgraphName,
           directory: inputs.directory,
           studio: inputs.studio,
@@ -588,7 +587,7 @@ Make sure to visit the documentation on https://thegraph.com/docs/ for further i
 
 const initSubgraphFromExample = async (
   toolbox,
-  { allowSimpleName, subgraphName, directory, studio, product },
+  { fromExample, allowSimpleName, subgraphName, directory, studio, product },
   { commands },
 ) => {
   let { filesystem, print, system } = toolbox
@@ -612,10 +611,32 @@ const initSubgraphFromExample = async (
     `Failed to clone example subgraph`,
     `Warnings while cloning example subgraph`,
     async spinner => {
-      await system.run(
-        `git clone http://github.com/graphprotocol/example-subgraph ${directory}`,
-      )
-      return true
+      // Create a temporary directory
+      const prefix = path.join(os.tmpdir(), 'example-subgraph-')
+      const tmpDir = fs.mkdtempSync(prefix)
+
+      try {
+        await system.run(
+          `git clone http://github.com/graphprotocol/example-subgraphs ${tmpDir}`
+        )
+
+        // If an example is not specified, use the default one
+        if (fromExample === undefined || fromExample === true) {
+          fromExample = DEFAULT_EXAMPLE_SUBGRAPH
+        }
+
+        const exampleSubgraphPath = path.join(tmpDir, fromExample);
+
+        if (!filesystem.exists(exampleSubgraphPath)) {
+          return { result: false, error: `Example not found: ${fromExample}` }
+        }
+
+        filesystem.copy(exampleSubgraphPath, directory)
+        return true
+      }
+      finally {
+        filesystem.remove(tmpDir)
+      }
     },
   )
   if (!cloned) {

package/src/protocols/ethereum/abi.js

@@ -5,6 +5,7 @@ const path = require('path')
 const AbiCodeGenerator = require('./codegen/abi')
 
 const TUPLE_ARRAY_PATTERN = /^tuple\[([0-9]*)\]$/
+const TUPLE_MATRIX_PATTERN = /^tuple\[([0-9]*)\]\[([0-9]*)\]$/
 
 const buildOldSignatureParameter = input => {
   return input.get('type') === 'tuple'
@@ -27,6 +28,13 @@ const buildSignatureParameter = input => {
       .get('components')
       .map(component => buildSignatureParameter(component))
       .join(',')})[${length ? length : ''}]`
+  } else if (input.get('type').match(TUPLE_MATRIX_PATTERN)) {
+    const length1 = input.get('type').match(TUPLE_MATRIX_PATTERN)[1]
+    const length2 = input.get('type').match(TUPLE_MATRIX_PATTERN)[2]
+    return `(${input.get('indexed') ? 'indexed ' : ''}${input
+      .get('components')
+      .map(component => buildSignatureParameter(component))
+      .join(',')})[${length1 ? length1 : ''}][${length2 ? length2 : ''}]`
   } else {
     return `${input.get('indexed') ? 'indexed ' : ''}${input.get('type')}`
   }

package/src/protocols/ethereum/codegen/abi.js

@@ -362,7 +362,11 @@ module.exports = class AbiCodeGenerator {
     let tupleGetter = tsCodegen.method(
       `get ${name}`,
       [],
-      util.isTupleArrayType(type) ? `Array<${tupleClassName}>` : tupleClassName,
+      util.isTupleMatrixType(type)
+      ? `Array<Array<${tupleClassName}>>`
+      : util.isTupleArrayType(type)
+      ? `Array<${tupleClassName}>`
+      : tupleClassName,
       `
       return ${
         isTupleType ? `changetype<${tupleClassName}>(${returnValue})` : `${returnValue}`
@@ -686,6 +690,13 @@ module.exports = class AbiCodeGenerator {
     const type = inputOrOutput.get('type')
     return util.isTupleType(type)
       ? this._tupleTypeName(inputOrOutput, index, tupleParentType, this.abi.name)
+      : util.isTupleMatrixType(type)
+      ? `Array<Array<${this._tupleTypeName(
+          inputOrOutput,
+          index,
+          tupleParentType,
+          this.abi.name,
+        )}>>`
       : util.isTupleArrayType(type)
       ? `Array<${this._tupleTypeName(
           inputOrOutput,

package/src/scaffold/index.js

@@ -53,7 +53,7 @@ module.exports = class Scaffold {
         },
         dependencies: {
           '@graphprotocol/graph-cli': GRAPH_CLI_VERSION,
-          '@graphprotocol/graph-ts': `0.27.0`,
+          '@graphprotocol/graph-ts': `0.28.0`,
         },
         devDependencies: this.protocol.hasEvents() ? { 'matchstick-as': `0.5.0`} : undefined,
       }),

package/src/subgraph.js

@@ -100,17 +100,18 @@ module.exports = class Subgraph {
   }
 
   static validateRepository(manifest, { resolveFile }) {
-    return manifest.get('repository') !==
-      'https://github.com/graphprotocol/example-subgraph'
-      ? immutable.List()
-      : immutable.List().push(
+    const repository = manifest.get('repository')
+
+    return /^https:\/\/github\.com\/graphprotocol\/example-subgraphs?$/.test(repository)
+      ? immutable.List().push(
           immutable.fromJS({
             path: ['repository'],
             message: `\
-The repository is still set to https://github.com/graphprotocol/example-subgraph.
+The repository is still set to ${repository}.
 Please replace it with a link to your subgraph source code.`,
           }),
         )
+      : immutable.List()
   }
 
   static validateDescription(manifest, { resolveFile }) {

package/tests/cli/init.test.js

@@ -15,6 +15,7 @@ describe('Init', () => {
         'ethereum',
         '--studio',
         '--from-example',
+        'ethereum/gravatar',
         'user/example-subgraph',
         path.join(ethereumBaseDir, 'from-example'),
       ],