@graphprotocol/graph-cli 0.37.3 → 0.37.4

package/src/codegen/schema.ts

@@ -1,299 +0,0 @@
-import immutable from 'immutable';
-import Schema from '../schema';
-import * as typesCodegen from './types';
-import * as tsCodegen from './typescript';
-
-class IdField {
-  static BYTES = Symbol('Bytes');
-  static STRING = Symbol('String');
-
-  private kind: typeof IdField.BYTES | typeof IdField.STRING;
-
-  constructor(idField: immutable.Map<any, any>) {
-    const typeName = idField.getIn(['type', 'type', 'name', 'value']);
-    this.kind = typeName === 'Bytes' ? IdField.BYTES : IdField.STRING;
-  }
-
-  typeName() {
-    return this.kind === IdField.BYTES ? 'Bytes' : 'string';
-  }
-
-  gqlTypeName() {
-    return this.kind === IdField.BYTES ? 'Bytes' : 'String';
-  }
-
-  tsNamedType() {
-    return tsCodegen.namedType(this.typeName());
-  }
-
-  tsValueFrom() {
-    return this.kind === IdField.BYTES ? 'Value.fromBytes(id)' : 'Value.fromString(id)';
-  }
-
-  tsValueKind() {
-    return this.kind === IdField.BYTES ? 'ValueKind.BYTES' : 'ValueKind.STRING';
-  }
-
-  tsValueToString() {
-    return this.kind == IdField.BYTES ? 'id.toBytes().toHexString()' : 'id.toString()';
-  }
-
-  tsToString() {
-    return this.kind == IdField.BYTES ? 'id.toHexString()' : 'id';
-  }
-
-  static fromFields(fields: immutable.List<any>) {
-    const idField = fields.find(field => field.getIn(['name', 'value']) === 'id');
-    return new IdField(idField);
-  }
-
-  static fromTypeDef(def: immutable.Map<any, any>) {
-    return IdField.fromFields(def.get('fields'));
-  }
-}
-
-export default class SchemaCodeGenerator {
-  constructor(private schema: Schema) {
-    this.schema = schema;
-  }
-
-  generateModuleImports() {
-    return [
-      tsCodegen.moduleImports(
-        [
-          // Base classes
-          'TypedMap',
-          'Entity',
-          'Value',
-          'ValueKind',
-
-          // APIs
-          'store',
-
-          // Basic Scalar types
-          'Bytes',
-          'BigInt',
-          'BigDecimal',
-        ],
-        '@graphprotocol/graph-ts',
-      ),
-    ];
-  }
-
-  generateTypes() {
-    return this.schema.ast
-      .get('definitions')
-      .filter((def: any) => this._isEntityTypeDefinition(def))
-      .map((def: any) => this._generateEntityType(def));
-  }
-
-  _isEntityTypeDefinition(def: immutable.Map<any, any>) {
-    return (
-      def.get('kind') === 'ObjectTypeDefinition' &&
-      def
-        .get('directives')
-        .find((directive: any) => directive.getIn(['name', 'value']) === 'entity') !== undefined
-    );
-  }
-
-  _isInterfaceDefinition(def: immutable.Map<any, any>) {
-    return def.get('kind') === 'InterfaceTypeDefinition';
-  }
-
-  _generateEntityType(def: immutable.Map<any, any>) {
-    const name = def.getIn(['name', 'value']) as string;
-    const klass = tsCodegen.klass(name, { export: true, extends: 'Entity' });
-    const fields = def.get('fields');
-    const idField = IdField.fromFields(fields);
-
-    // Generate and add a constructor
-    klass.addMethod(this._generateConstructor(name, fields));
-
-    // Generate and add save() and getById() methods
-    this._generateStoreMethods(name, idField).forEach(method => klass.addMethod(method));
-
-    // Generate and add entity field getters and setters
-    def
-      .get('fields')
-      .reduce(
-        (methods: any, field: any) => methods.concat(this._generateEntityFieldMethods(def, field)),
-        immutable.List(),
-      )
-      .forEach((method: any) => klass.addMethod(method));
-
-    return klass;
-  }
-
-  _generateConstructor(_entityName: string, fields: immutable.List<any>) {
-    const idField = IdField.fromFields(fields);
-    return tsCodegen.method(
-      'constructor',
-      [tsCodegen.param('id', idField.tsNamedType())],
-      undefined,
-      `
-      super()
-      this.set('id', ${idField.tsValueFrom()})
-      `,
-    );
-  }
-
-  _generateStoreMethods(entityName: any, idField: any) {
-    return immutable.List.of<tsCodegen.Method | tsCodegen.StaticMethod>(
-      tsCodegen.method(
-        'save',
-        [],
-        tsCodegen.namedType('void'),
-        `
-        let id = this.get('id')
-        assert(id != null,
-               'Cannot save ${entityName} entity without an ID')
-        if (id) {
-          assert(id.kind == ${idField.tsValueKind()},
-                 \`Entities of type ${entityName} must have an ID of type ${idField.gqlTypeName()} but the id '\${id.displayData()}' is of type \${id.displayKind()}\`)
-          store.set('${entityName}', ${idField.tsValueToString()}, this)
-        }`,
-      ),
-
-      tsCodegen.staticMethod(
-        'load',
-        [tsCodegen.param('id', tsCodegen.namedType(idField.typeName()))],
-        tsCodegen.nullableType(tsCodegen.namedType(entityName)),
-        `
-        return changetype<${entityName} | null>(store.get('${entityName}', ${idField.tsToString()}))
-        `,
-      ),
-    );
-  }
-
-  _generateEntityFieldMethods(entityDef: any, fieldDef: immutable.Map<any, any>) {
-    return immutable.List([
-      this._generateEntityFieldGetter(entityDef, fieldDef),
-      this._generateEntityFieldSetter(entityDef, fieldDef),
-    ]);
-  }
-
-  _generateEntityFieldGetter(_entityDef: any, fieldDef: immutable.Map<any, any>) {
-    const name = fieldDef.getIn(['name', 'value']);
-    const gqlType = fieldDef.get('type');
-    const fieldValueType = this._valueTypeFromGraphQl(gqlType);
-    const returnType = this._typeFromGraphQl(gqlType);
-    const isNullable = returnType instanceof tsCodegen.NullableType;
-
-    const getNonNullable = `return ${typesCodegen.valueToAsc('value!', fieldValueType)}`;
-    const getNullable = `if (!value || value.kind == ValueKind.NULL) {
-                          return null
-                        } else {
-                          return ${typesCodegen.valueToAsc('value', fieldValueType)}
-                        }`;
-
-    return tsCodegen.method(
-      `get ${name}`,
-      [],
-      returnType,
-      `
-       let value = this.get('${name}')
-       ${isNullable ? getNullable : getNonNullable}
-      `,
-    );
-  }
-
-  _generateEntityFieldSetter(_entityDef: any, fieldDef: immutable.Map<any, any>) {
-    const name = fieldDef.getIn(['name', 'value']);
-    const gqlType = fieldDef.get('type');
-    const fieldValueType = this._valueTypeFromGraphQl(gqlType);
-    const paramType = this._typeFromGraphQl(gqlType);
-    const isNullable = paramType instanceof tsCodegen.NullableType;
-    const paramTypeString = isNullable ? paramType.inner.toString() : paramType.toString();
-    const isArray = paramType instanceof tsCodegen.ArrayType;
-
-    if (isArray && paramType.inner instanceof tsCodegen.NullableType) {
-      const baseType = this._baseType(gqlType);
-
-      throw new Error(`
-GraphQL schema can't have List's with Nullable members.
-Error in '${name}' field of type '[${baseType}]'.
-Suggestion: add an '!' to the member type of the List, change from '[${baseType}]' to '[${baseType}!]'`);
-    }
-
-    const setNonNullable = `
-      this.set('${name}', ${typesCodegen.valueFromAsc(`value`, fieldValueType)})
-    `;
-    const setNullable = `
-      if (!value) {
-        this.unset('${name}')
-      } else {
-        this.set('${name}', ${typesCodegen.valueFromAsc(
-      `<${paramTypeString}>value`,
-      fieldValueType,
-    )})
-      }
-    `;
-
-    return tsCodegen.method(
-      `set ${name}`,
-      [tsCodegen.param('value', paramType)],
-      undefined,
-      isNullable ? setNullable : setNonNullable,
-    );
-  }
-
-  _resolveFieldType(gqlType: immutable.Map<any, any>) {
-    const typeName = gqlType.getIn(['name', 'value']);
-
-    // If this is a reference to another type, the field has the type of
-    // the referred type's id field
-    const typeDef = this.schema.ast
-      .get('definitions')
-      .find(
-        (def: any) =>
-          (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
-          def.getIn(['name', 'value']) === typeName,
-      );
-    if (typeDef) {
-      return IdField.fromTypeDef(typeDef).typeName();
-    }
-    return typeName as string;
-  }
-
-  /** Return the type that values for this field must have. For scalar
-   * types, that's the type from the subgraph schema. For references to
-   * other entity types, this is the same as the type of the id of the
-   * referred type, i.e., `string` or `Bytes`*/
-  _valueTypeFromGraphQl(gqlType: immutable.Map<any, any>): any {
-    if (gqlType.get('kind') === 'NonNullType') {
-      return this._valueTypeFromGraphQl(gqlType.get('type'));
-    }
-    if (gqlType.get('kind') === 'ListType') {
-      return '[' + this._valueTypeFromGraphQl(gqlType.get('type')) + ']';
-    }
-    return this._resolveFieldType(gqlType);
-  }
-
-  /** Determine the base type of `gqlType` by removing any non-null
-   * constraints and using the type of elements of lists */
-  _baseType(gqlType: immutable.Map<any, any>): any {
-    if (gqlType.get('kind') === 'NonNullType') {
-      return this._baseType(gqlType.get('type'));
-    }
-    if (gqlType.get('kind') === 'ListType') {
-      return this._baseType(gqlType.get('type'));
-    }
-    return gqlType.getIn(['name', 'value']);
-  }
-
-  _typeFromGraphQl(gqlType: immutable.Map<any, any>, nullable = true): any {
-    if (gqlType.get('kind') === 'NonNullType') {
-      return this._typeFromGraphQl(gqlType.get('type'), false);
-    }
-    if (gqlType.get('kind') === 'ListType') {
-      const type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.get('type')));
-      return nullable ? tsCodegen.nullableType(type) : type;
-    }
-    // NamedType
-    const type = tsCodegen.namedType(
-      typesCodegen.ascTypeForValue(this._resolveFieldType(gqlType)) as any,
-    );
-    // In AssemblyScript, primitives cannot be nullable.
-    return nullable && !type.isPrimitive() ? tsCodegen.nullableType(type) : type;
-  }
-}

package/src/codegen/template.ts

@@ -1,45 +0,0 @@
-import immutable from 'immutable';
-import Protocol from '../protocols';
-import IpfsFileTemplateCodeGen from '../protocols/ipfs/codegen/file_template';
-import * as tsCodegen from './typescript';
-
-export default class DataSourceTemplateCodeGenerator {
-  protocolTemplateCodeGen: any;
-
-  constructor(public template: immutable.Map<any, any>, protocol: Protocol) {
-    this.template = template;
-    const kind = template.get('kind');
-
-    if (kind.split('/')[0] == protocol.name) {
-      this.protocolTemplateCodeGen = protocol.getTemplateCodeGen(template);
-    } else if (kind == 'file/ipfs') {
-      this.protocolTemplateCodeGen = new IpfsFileTemplateCodeGen(template);
-    }
-  }
-
-  generateModuleImports() {
-    return [
-      tsCodegen.moduleImports(
-        [
-          ...this.protocolTemplateCodeGen.generateModuleImports(),
-          'DataSourceTemplate',
-          'DataSourceContext',
-        ],
-        '@graphprotocol/graph-ts',
-      ),
-    ];
-  }
-
-  generateTypes() {
-    return immutable.List([this._generateTemplateType()]);
-  }
-
-  _generateTemplateType() {
-    const name = this.template.get('name');
-
-    const klass = tsCodegen.klass(name, { export: true, extends: 'DataSourceTemplate' });
-    klass.addMethod(this.protocolTemplateCodeGen.generateCreateMethod());
-    klass.addMethod(this.protocolTemplateCodeGen.generateCreateWithContextMethod());
-    return klass;
-  }
-}

package/src/codegen/types/conversions.ts

@@ -1,358 +0,0 @@
-import immutable from 'immutable';
-
-/**
- * ethereum.Value -> AssemblyScript conversions
- */
-const ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT = [
-  // Scalar values
-
-  ['address', 'Address', (code: any) => `${code}.toAddress()`],
-  ['bool', 'boolean', (code: any) => `${code}.toBoolean()`],
-  ['byte', 'Bytes', (code: any) => `${code}.toBytes()`],
-  [
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?$/,
-    'Bytes',
-    (code: any) => `${code}.toBytes()`,
-  ],
-  [/^int(8|16|24|32)$/, 'i32', (code: any) => `${code}.toI32()`],
-  [/^uint(8|16|24)$/, 'i32', (code: any) => `${code}.toI32()`],
-  ['uint32', 'BigInt', (code: any) => `${code}.toBigInt()`],
-  [
-    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
-    'BigInt',
-    (code: any) => `${code}.toBigInt()`,
-  ],
-  ['string', 'string', (code: any) => `${code}.toString()`],
-
-  // Arrays
-
-  [/^address\[([0-9]+)?\]$/, 'Array<Address>', (code: any) => `${code}.toAddressArray()`],
-  [/^bool\[([0-9]+)?\]$/, 'Array<boolean>', (code: any) => `${code}.toBooleanArray()`],
-  [/^byte\[([0-9]+)?\]$/, 'Array<Bytes>', (code: any) => `${code}.toBytesArray()`],
-  [
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?\[([0-9]+)?\]$/,
-    'Array<Bytes>',
-    (code: any) => `${code}.toBytesArray()`,
-  ],
-  [/^int(8|16|24|32)\[([0-9]+)?\]$/, 'Array<i32>', (code: any) => `${code}.toI32Array()`],
-  [/^uint(8|16|24)\[([0-9]+)?\]$/, 'Array<i32>', (code: any) => `${code}.toI32Array()`],
-  [/^uint32\[([0-9]+)?\]$/, 'Array<BigInt>', (code: any) => `${code}.toBigIntArray()`],
-  [
-    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
-    'Array<BigInt>',
-    (code: any) => `${code}.toBigIntArray()`,
-  ],
-  [/^string\[([0-9]+)?\]$/, 'Array<string>', (code: any) => `${code}.toStringArray()`],
-
-  // Tuples
-
-  ['tuple', 'ethereum.Tuple', (code: any) => `${code}.toTuple()`],
-  [
-    /^tuple\[([0-9]+)?\]$/,
-    'Array<ethereum.Tuple>',
-    (code: any, type: any) => `${code}.toTupleArray<${type}>()`,
-  ],
-
-  // Multi dimensional arrays
-
-  [
-    /^address\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<Address>>',
-    (code: any) => `${code}.toAddressMatrix()`,
-  ],
-  [
-    /^bool\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<boolean>>',
-    (code: any) => `${code}.toBooleanMatrix()`,
-  ],
-  [
-    /^byte\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<Bytes>>',
-    (code: any) => `${code}.toBytesMatrix()`,
-  ],
-  [
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<Bytes>>',
-    (code: any) => `${code}.toBytesMatrix()`,
-  ],
-  [
-    /^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<i32>>',
-    (code: any) => `${code}.toI32Matrix()`,
-  ],
-  [
-    /^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<i32>>',
-    (code: any) => `${code}.toI32Matrix()`,
-  ],
-  [
-    /^uint32\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<BigInt>>',
-    (code: any) => `${code}.toBigIntMatrix()`,
-  ],
-  [
-    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<BigInt>>',
-    (code: any) => `${code}.toBigIntMatrix()`,
-  ],
-  [
-    /^string\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<string>>',
-    (code: any) => `${code}.toStringMatrix()`,
-  ],
-  [
-    /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<ethereum.Tuple>>',
-    (code: any, type: any) => `${code}.toTupleMatrix<${type}>()`,
-  ],
-];
-
-/**
- * AssemblyScript -> ethereum.Value conversions
- *
- * Note: The order and patterns for conversions in this direction differ slightly
- * from ethereum.Value -> AssemblyScript, which is why there is a separate table
- * for them.
- */
-const ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE = [
-  // Scalar values
-
-  ['Address', 'address', (code: any) => `ethereum.Value.fromAddress(${code})`],
-  ['boolean', 'bool', (code: any) => `ethereum.Value.fromBoolean(${code})`],
-  ['Bytes', 'byte', (code: any) => `ethereum.Value.fromFixedBytes(${code})`],
-  ['Bytes', 'bytes', (code: any) => `ethereum.Value.fromBytes(${code})`],
-  [
-    'Bytes',
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)$/,
-    (code: any) => `ethereum.Value.fromFixedBytes(${code})`,
-  ],
-  ['i32', /^int(8|16|24|32)$/, (code: any) => `ethereum.Value.fromI32(${code})`],
-  [
-    'i32',
-    /^uint(8|16|24)$/,
-    (code: any) => `ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(${code}))`,
-  ],
-  [
-    'BigInt',
-    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
-    (code: any) => `ethereum.Value.fromSignedBigInt(${code})`,
-  ],
-  [
-    'BigInt',
-    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
-    (code: any) => `ethereum.Value.fromUnsignedBigInt(${code})`,
-  ],
-  ['string', 'string', (code: any) => `ethereum.Value.fromString(${code})`],
-
-  // Arrays
-
-  [
-    'Array<Address>',
-    /^address\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromAddressArray(${code})`,
-  ],
-  [
-    'Array<boolean>',
-    /^bool\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromBooleanArray(${code})`,
-  ],
-  [
-    'Array<Bytes>',
-    /^byte\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromFixedBytesArray(${code})`,
-  ],
-  ['Array<Bytes>', /bytes\[([0-9]+)?\]$/, (code: any) => `ethereum.Value.fromBytesArray(${code})`],
-  [
-    'Array<Bytes>',
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromFixedBytesArray(${code})`,
-  ],
-  [
-    'Array<i32>',
-    /^int(8|16|24|32)\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromI32Array(${code})`,
-  ],
-  [
-    'Array<i32>',
-    /^uint(8|16|24)\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromI32Array(${code})`,
-  ],
-  [
-    'Array<BigInt>',
-    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromSignedBigIntArray(${code})`,
-  ],
-  [
-    'Array<BigInt>',
-    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromUnsignedBigIntArray(${code})`,
-  ],
-  [
-    'Array<string>',
-    /^string\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromStringArray(${code})`,
-  ],
-
-  // Tuples
-
-  ['ethereum.Tuple', 'tuple', (code: any) => `ethereum.Value.fromTuple(${code})`],
-  [
-    'Array<ethereum.Tuple>',
-    /^tuple\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromTupleArray(${code})`,
-  ],
-
-  // Multi dimentional arrays
-
-  [
-    'Array<Array<Address>>',
-    /^address\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromAddressMatrix(${code})`,
-  ],
-  [
-    'Array<Array<boolean>>',
-    /^bool\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromBooleanMatrix(${code})`,
-  ],
-  [
-    'Array<Array<Bytes>>',
-    /^byte\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromFixedBytesMatrix(${code})`,
-  ],
-  [
-    'Array<Array<Bytes>>',
-    /bytes\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromBytesMatrix(${code})`,
-  ],
-  [
-    'Array<Array<Bytes>>',
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromFixedBytesMatrix(${code})`,
-  ],
-  [
-    'Array<Array<i32>>',
-    /^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromI32Matrix(${code})`,
-  ],
-  [
-    'Array<Array<i32>>',
-    /^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromI32Matrix(${code})`,
-  ],
-  [
-    'Array<Array<BigInt>>',
-    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromSignedBigIntMatrix(${code})`,
-  ],
-  [
-    'Array<Array<BigInt>>',
-    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromUnsignedBigIntMatrix(${code})`,
-  ],
-  [
-    'Array<Array<string>>',
-    /^string\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromStringMatrix(${code})`,
-  ],
-  [
-    'Array<Array<ethereum.Tuple>>',
-    /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    (code: any) => `ethereum.Value.fromTupleMatrix(${code})`,
-  ],
-];
-
-/**
- * Value -> AssemblyScript conversions
- */
-const VALUE_TO_ASSEMBLYSCRIPT = [
-  // Arrays
-
-  ['[Bytes]', 'Array<Bytes>', (code: any) => `${code}.toBytesArray()`],
-  ['[Boolean]', 'Array<boolean>', (code: any) => `${code}.toBooleanArray()`],
-  ['[Int]', 'Array<i32>', (code: any) => `${code}.toI32Array()`],
-  ['[BigInt]', 'Array<BigInt>', (code: any) => `${code}.toBigIntArray()`],
-  ['[ID]', 'Array<string>', (code: any) => `${code}.toStringArray()`],
-  ['[String]', 'Array<string>', (code: any) => `${code}.toStringArray()`],
-  ['[BigDecimal]', 'Array<BigDecimal>', (code: any) => `${code}.toBigDecimalArray()`],
-  [/\[.*\]/, 'Array<string>', (code: any) => `${code}.toStringArray()`],
-
-  // Scalar values
-
-  ['Bytes', 'Bytes', (code: any) => `${code}.toBytes()`],
-  ['Boolean', 'boolean', (code: any) => `${code}.toBoolean()`],
-  ['Int', 'i32', (code: any) => `${code}.toI32()`],
-  ['BigInt', 'BigInt', (code: any) => `${code}.toBigInt()`],
-  ['ID', 'string', (code: any) => `${code}.toString()`],
-  ['String', 'string', (code: any) => `${code}.toString()`],
-  ['BigDecimal', 'BigDecimal', (code: any) => `${code}.toBigDecimal()`],
-  [/.*/, 'string', (code: any) => `${code}.toString()`],
-];
-
-/**
- * AssemblyScript -> Value conversions
- *
- * Note: The order and patterns for conversions in this direction differ slightly
- * from Value -> AssemblyScript, which is why there is a separate table
- * for them.
- */
-const ASSEMBLYSCRIPT_TO_VALUE = [
-  // Matrices
-
-  ['Array<Array<Address>>', '[[Bytes]]', (code: any) => `Value.fromBytesMatrix(${code})`],
-  ['Array<Array<Bytes>>', '[[Bytes]]', (code: any) => `Value.fromBytesMatrix(${code})`],
-  ['Array<Array<boolean>>', '[[Boolean]]', (code: any) => `Value.fromBooleanMatrix(${code})`],
-  ['Array<Array<i32>>', '[[Int]]', (code: any) => `Value.fromI32Matrix(${code})`],
-  ['Array<Array<BigInt>>', '[[BigInt]]', (code: any) => `Value.fromBigIntMatrix(${code})`],
-  ['Array<Array<string>>', '[[String]]', (code: any) => `Value.fromStringMatrix(${code})`],
-  ['Array<Array<string>>', '[[ID]]', (code: any) => `Value.fromStringMatrix(${code})`],
-  [
-    'Array<Array<BigDecimal>>',
-    '[[BigDecimal]]',
-    (code: any) => `Value.fromBigDecimalMatrix(${code})`,
-  ],
-  ['Array<Array<string>>', /\[\[.*\]\]/, (code: any) => `Value.fromStringMatrix(${code})`],
-  ['Array<Array<string | null>>', null, (code: any) => `Value.fromStringMatrix(${code})`], // is this overwriting the Array null below?
-
-  // Arrays
-
-  ['Array<Address>', '[Bytes]', (code: any) => `Value.fromBytesArray(${code})`],
-  ['Array<Bytes>', '[Bytes]', (code: any) => `Value.fromBytesArray(${code})`],
-  ['Array<boolean>', '[Boolean]', (code: any) => `Value.fromBooleanArray(${code})`],
-  ['Array<i32>', '[Int]', (code: any) => `Value.fromI32Array(${code})`],
-  ['Array<BigInt>', '[BigInt]', (code: any) => `Value.fromBigIntArray(${code})`],
-  ['Array<string>', '[String]', (code: any) => `Value.fromStringArray(${code})`],
-  ['Array<string>', '[ID]', (code: any) => `Value.fromStringArray(${code})`],
-  ['Array<BigDecimal>', '[BigDecimal]', (code: any) => `Value.fromBigDecimalArray(${code})`],
-  ['Array<string>', /\[.*\]/, (code: any) => `Value.fromStringArray(${code})`],
-  ['Array<string | null>', null, (code: any) => `Value.fromStringArray(${code})`],
-
-  // Scalar values
-
-  ['Address', 'Bytes', (code: any) => `Value.fromBytes(${code})`],
-  ['Bytes', 'Bytes', (code: any) => `Value.fromBytes(${code})`],
-  ['boolean', 'Boolean', (code: any) => `Value.fromBoolean(${code})`],
-  ['i32', 'Int', (code: any) => `Value.fromI32(${code})`],
-  ['BigInt', 'BigInt', (code: any) => `Value.fromBigInt(${code})`],
-  ['string', 'String', (code: any) => `Value.fromString(${code})`],
-  ['string', 'ID', (code: any) => `Value.fromString(${code})`],
-  ['BigDecimal', 'BigDecimal', (code: any) => `Value.fromBigDecimal(${code})`],
-  ['string', /.*/, (code: any) => `Value.fromString(${code})`],
-];
-
-const CONVERSIONS = {
-  ethereum: {
-    AssemblyScript: ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT,
-  },
-  AssemblyScript: {
-    ethereum: ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE,
-    Value: ASSEMBLYSCRIPT_TO_VALUE,
-  },
-  Value: {
-    AssemblyScript: VALUE_TO_ASSEMBLYSCRIPT,
-  },
-} as const;
-
-/**
- * Type conversions
- */
-export default immutable.fromJS(CONVERSIONS);