@graphprotocol/graph-cli 0.33.1 → 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/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-alpha.0`,
         },
         devDependencies: this.protocol.hasEvents() ? { 'matchstick-as': `0.5.0`} : undefined,
       }),