@graphprotocol/graph-cli 0.37.4 → 0.37.5

package/dist/protocols/cosmos/manifest.graphql

@@ -0,0 +1,76 @@
+# Each referenced type's in any of the types below must be listed
+# here either as `scalar` or `type` for the validation code to work
+# properly.
+#
+# That's why `String` is listed as a scalar even though it's built-in
+# GraphQL basic types.
+scalar String
+scalar File
+scalar BigInt
+
+type SubgraphManifest {
+  specVersion: String!
+  features: [String!]
+  schema: Schema!
+  description: String
+  repository: String
+  graft: Graft
+  dataSources: [DataSource!]!
+}
+
+type Schema {
+  file: File!
+}
+
+type DataSource {
+  kind: String!
+  name: String!
+  network: String
+  source: ContractSource!
+  mapping: ContractMapping!
+}
+
+type ContractSource {
+  startBlock: BigInt
+}
+
+type ContractMapping {
+  apiVersion: String!
+  language: String!
+  file: File!
+  entities: [String!]!
+  blockHandlers: [BlockHandler!]
+  eventHandlers: [EventHandler!]
+  transactionHandlers: [TransactionHandler!]
+  messageHandlers: [MessageHandler!]
+}
+
+type BlockHandler {
+  handler: String!
+}
+
+enum EventOrigin {
+  BeginBlock
+  DeliverTx
+  EndBlock
+}
+
+type EventHandler {
+  event: String!
+  origin: EventOrigin
+  handler: String!
+}
+
+type TransactionHandler {
+  handler: String!
+}
+
+type MessageHandler {
+  message: String!
+  handler: String!
+}
+
+type Graft {
+  base: String!
+  block: BigInt!
+}

package/dist/protocols/cosmos/scaffold/manifest.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapping = exports.source = void 0;
+const source = () => `
+      startBlock: 0`;
+exports.source = source;
+const mapping = () => `
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - ExampleEntity
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/contract.ts`;
+exports.mapping = mapping;

package/dist/protocols/cosmos/scaffold/mapping.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlaceholderHandlers = void 0;
+const generatePlaceholderHandlers = () => `
+  import { cosmos, BigInt } from '@graphprotocol/graph-ts'
+  import { ExampleEntity } from '../generated/schema'
+
+  export function handleBlock(block: cosmos.Block): void {
+    // Entities can be loaded from the store using a string ID; this ID
+    // needs to be unique across all entities of the same type
+    let entity = ExampleEntity.load(block.header.hash.toHex())
+
+    // Entities only exist after they have been saved to the store;
+    // \`null\` checks allow to create entities on demand
+    if (!entity) {
+      entity = new ExampleEntity(block.header.hash.toHex())
+
+      // Entity fields can be set using simple assignments
+      entity.count = BigInt.fromI32(0)
+    }
+
+    // BigInt and BigDecimal math are supported
+    entity.count = entity.count + BigInt.fromI32(1)
+
+    // Entity fields can be set based on receipt information
+    entity.height = block.header.height
+
+    // Entities can be written to the store with \`.save()\`
+    entity.save()
+
+    // Note: If a handler doesn't require existing field values, it is faster
+    // _not_ to load the entity from the store. Instead, create it fresh with
+    // \`new Entity(...)\`, set the fields that should be updated and save the
+    // entity back to the store. Fields that were not set or unset remain
+    // unchanged, allowing for partial updates to be applied.
+  }
+`;
+exports.generatePlaceholderHandlers = generatePlaceholderHandlers;

package/dist/protocols/cosmos/subgraph.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+class CosmosSubgraph {
+    manifest;
+    resolveFile;
+    protocol;
+    constructor(options) {
+        this.manifest = options.manifest;
+        this.resolveFile = options.resolveFile;
+        this.protocol = options.protocol;
+    }
+    validateManifest() {
+        return immutable_1.default.List();
+    }
+    handlerTypes() {
+        return immutable_1.default.List([
+            'blockHandlers',
+            'eventHandlers',
+            'transactionHandlers',
+            'messageHandlers',
+        ]);
+    }
+}
+exports.default = CosmosSubgraph;

package/dist/protocols/ethereum/abi.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const immutable_1 = __importDefault(require("immutable"));
+const abi_1 = __importDefault(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'
+        ? `(${input
+            .get('components')
+            .map((component) => buildSignatureParameter(component))
+            .join(',')})`
+        : String(input.get('type'));
+};
+const buildSignatureParameter = (input) => {
+    if (input.get('type') === 'tuple') {
+        return `(${input.get('indexed') ? 'indexed ' : ''}${input
+            .get('components')
+            .map((component) => buildSignatureParameter(component))
+            .join(',')})`;
+    }
+    if (input.get('type').match(TUPLE_ARRAY_PATTERN)) {
+        const length = input.get('type').match(TUPLE_ARRAY_PATTERN)[1];
+        return `(${input.get('indexed') ? 'indexed ' : ''}${input
+            .get('components')
+            .map((component) => buildSignatureParameter(component))
+            .join(',')})[${length ? length : ''}]`;
+    }
+    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 : ''}]`;
+    }
+    return `${input.get('indexed') ? 'indexed ' : ''}${input.get('type')}`;
+};
+class ABI {
+    name;
+    file;
+    data;
+    constructor(name, file, data) {
+        this.name = name;
+        this.file = file;
+        this.data = data;
+        this.name = name;
+        this.file = file;
+        this.data = data;
+    }
+    codeGenerator() {
+        return new abi_1.default(this);
+    }
+    static oldEventSignature(event) {
+        return `${event.get('name')}(${event
+            .get('inputs', [])
+            .map(buildOldSignatureParameter)
+            .join(',')})`;
+    }
+    static eventSignature(event) {
+        return `${event.get('name')}(${event
+            .get('inputs', [])
+            .map(buildSignatureParameter)
+            .join(',')})`;
+    }
+    /**
+     * For the ABI of a function, returns a string function signature compatible
+     * with the Rust `ethabi` library. It is of the form
+     *
+     *     <function>([<input-type-1>, ...])[:(<output-type-1,...)]
+     *
+     * A few examples for a function called `example`:
+     *
+     * - No inputs or outputs: `example()`
+     * - One input and output: `example(uint256):(bool)`
+     * - Multiple inputs and outputs: `example(uint256,(string,bytes32)):(bool,uint256)`
+     */
+    functionSignature(fn) {
+        const inputs = fn.get('inputs', []).map(buildSignatureParameter).join(',');
+        const outputs = fn.get('outputs', []).map(buildSignatureParameter).join(',');
+        return `${fn.get('name')}(${inputs})${outputs.length > 0 ? `:(${outputs})` : ''}`;
+    }
+    oldEventSignatures() {
+        return this.data
+            .filter((entry) => entry.get('type') === 'event')
+            .map(ABI.oldEventSignature);
+    }
+    eventSignatures() {
+        return this.data.filter((entry) => entry.get('type') === 'event').map(ABI.eventSignature);
+    }
+    callFunctions() {
+        // An entry is a function if its type is not set or if it is one of
+        // 'constructor', 'function' or 'fallback'
+        const functionTypes = immutable_1.default.Set(['constructor', 'function', 'fallback']);
+        const functions = this.data.filter((entry) => !entry.has('type') || functionTypes.includes(entry.get('type')));
+        // A function is a call function if it is nonpayable, payable or
+        // not constant
+        const mutabilityTypes = immutable_1.default.Set(['nonpayable', 'payable']);
+        return functions.filter((entry) => mutabilityTypes.includes(entry.get('stateMutability')) || entry.get('constant') === false);
+    }
+    callFunctionSignatures() {
+        return this.callFunctions()
+            .filter((entry) => entry.get('type') !== 'constructor')
+            .map((entry) => {
+            const name = entry.get('name', '<default>');
+            const inputs = entry
+                .get('inputs', immutable_1.default.List())
+                .map((input) => buildSignatureParameter(input));
+            return `${name}(${inputs.join(',')})`;
+        });
+    }
+    static normalized(json) {
+        if (Array.isArray(json)) {
+            return json;
+        }
+        if (json.abi !== undefined) {
+            return json.abi;
+        }
+        if (json.compilerOutput?.abi) {
+            return json.compilerOutput.abi;
+        }
+        return undefined;
+    }
+    static load(name, file) {
+        const data = JSON.parse(fs_extra_1.default.readFileSync(file).toString());
+        const abi = ABI.normalized(data);
+        if (abi === null || abi === undefined) {
+            throw Error(`No valid ABI in file: ${path_1.default.relative(process.cwd(), file)}`);
+        }
+        return new ABI(name, file, immutable_1.default.fromJS(abi));
+    }
+}
+exports.default = ABI;