@graphprotocol/graph-cli 0.37.4 → 0.37.5

package/dist/migrations/mapping_api_version_0_0_3.js

@@ -0,0 +1,83 @@
+"use strict";
+/* eslint-disable */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toolbox = __importStar(require("gluegun"));
+const semver_1 = __importDefault(require("semver"));
+const load_manifest_1 = require("./util/load-manifest");
+const versions_1 = require("./util/versions");
+// If any of the manifest apiVersions are 0.0.3, replace them with 0.0.4
+exports.default = {
+    name: 'Bump mapping apiVersion from 0.0.3 to 0.0.4',
+    predicate: async ({ sourceDir, manifestFile }) => {
+        // Obtain the graph-ts version, if possible
+        let graphTsVersion;
+        try {
+            graphTsVersion = await (0, versions_1.getGraphTsVersion)(sourceDir);
+        }
+        catch (_) {
+            // If we cannot obtain the version, return a hint that the graph-ts
+            // hasn't been installed yet
+            return 'graph-ts dependency not installed yet';
+        }
+        const manifest = await (0, load_manifest_1.loadManifest)(manifestFile);
+        return (
+        // Only migrate if the graph-ts version is > 0.17.0...
+        semver_1.default.gt(graphTsVersion, '0.17.0') &&
+            // ...and we have a manifest with mapping > apiVersion = 0.0.3
+            manifest &&
+            typeof manifest === 'object' &&
+            Array.isArray(manifest.dataSources) &&
+            (manifest.dataSources.reduce((hasOldMappings, dataSource) => hasOldMappings ||
+                (typeof dataSource === 'object' &&
+                    dataSource.mapping &&
+                    typeof dataSource.mapping === 'object' &&
+                    dataSource.mapping.apiVersion === '0.0.3'), false) ||
+                (Array.isArray(manifest.templates) &&
+                    manifest.templates.reduce((hasOldMappings, template) => hasOldMappings ||
+                        (typeof template === 'object' &&
+                            template.mapping &&
+                            typeof template.mapping === 'object' &&
+                            template.mapping.apiVersion === '0.0.3'), false))));
+    },
+    apply: async ({ manifestFile }) => {
+        // Make sure we catch all variants; we could load the manifest
+        // and replace the values in the data structures here; unfortunately
+        // writing that back to the file messes with the formatting more than
+        // we'd like; that's why for now, we use a simple patching approach
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp('apiVersion: 0.0.3', 'g'), 'apiVersion: 0.0.4');
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp("apiVersion: '0.0.3'", 'g'), "apiVersion: '0.0.4'");
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp('apiVersion: "0.0.3"', 'g'), 'apiVersion: "0.0.4"');
+    },
+};

package/dist/migrations/mapping_api_version_0_0_4.js

@@ -0,0 +1,85 @@
+"use strict";
+/* eslint-disable */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toolbox = __importStar(require("gluegun"));
+const semver_1 = __importDefault(require("semver"));
+const load_manifest_1 = require("./util/load-manifest");
+const versions_1 = require("./util/versions");
+// If any of the manifest apiVersions are 0.0.4, replace them with 0.0.5
+exports.default = {
+    name: 'Bump mapping apiVersion from 0.0.4 to 0.0.5',
+    predicate: async ({ sourceDir, manifestFile }) => {
+        // Obtain the graph-ts version, if possible
+        let graphTsVersion;
+        try {
+            graphTsVersion = await (0, versions_1.getGraphTsVersion)(sourceDir);
+        }
+        catch (_) {
+            // If we cannot obtain the version, return a hint that the graph-ts
+            // hasn't been installed yet
+            return 'graph-ts dependency not installed yet';
+        }
+        const manifest = await (0, load_manifest_1.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
+        // and in the `semver` library this would not return true on equality.
+        semver_1.default.gte(semver_1.default.coerce(graphTsVersion), '0.22.0') &&
+            // ...and we have a manifest with mapping > apiVersion = 0.0.4
+            manifest &&
+            typeof manifest === 'object' &&
+            Array.isArray(manifest.dataSources) &&
+            (manifest.dataSources.reduce((hasOldMappings, dataSource) => hasOldMappings ||
+                (typeof dataSource === 'object' &&
+                    dataSource.mapping &&
+                    typeof dataSource.mapping === 'object' &&
+                    dataSource.mapping.apiVersion === '0.0.4'), false) ||
+                (Array.isArray(manifest.templates) &&
+                    manifest.templates.reduce((hasOldMappings, template) => hasOldMappings ||
+                        (typeof template === 'object' &&
+                            template.mapping &&
+                            typeof template.mapping === 'object' &&
+                            template.mapping.apiVersion === '0.0.4'), false))));
+    },
+    apply: async ({ manifestFile }) => {
+        // Make sure we catch all variants; we could load the manifest
+        // and replace the values in the data structures here; unfortunately
+        // writing that back to the file messes with the formatting more than
+        // we'd like; that's why for now, we use a simple patching approach
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp('apiVersion: 0.0.4', 'g'), 'apiVersion: 0.0.5');
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp("apiVersion: '0.0.4'", 'g'), "apiVersion: '0.0.5'");
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp('apiVersion: "0.0.4"', 'g'), 'apiVersion: "0.0.5"');
+    },
+};

package/dist/migrations/mapping_api_version_0_0_5.js

@@ -0,0 +1,85 @@
+"use strict";
+/* eslint-disable */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toolbox = __importStar(require("gluegun"));
+const semver_1 = __importDefault(require("semver"));
+const load_manifest_1 = require("./util/load-manifest");
+const versions_1 = require("./util/versions");
+// If any of the manifest apiVersions are 0.0.5, replace them with 0.0.6
+exports.default = {
+    name: 'Bump mapping apiVersion from 0.0.5 to 0.0.6',
+    predicate: async ({ sourceDir, manifestFile }) => {
+        // Obtain the graph-ts version, if possible
+        let graphTsVersion;
+        try {
+            graphTsVersion = await (0, versions_1.getGraphTsVersion)(sourceDir);
+        }
+        catch (_) {
+            // If we cannot obtain the version, return a hint that the graph-ts
+            // hasn't been installed yet
+            return 'graph-ts dependency not installed yet';
+        }
+        const manifest = await (0, load_manifest_1.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
+        // and in the `semver` library this would not return true on equality.
+        semver_1.default.gte(semver_1.default.coerce(graphTsVersion), '0.24.0') &&
+            // ...and we have a manifest with mapping > apiVersion = 0.0.5
+            manifest &&
+            typeof manifest === 'object' &&
+            Array.isArray(manifest.dataSources) &&
+            (manifest.dataSources.reduce((hasOldMappings, dataSource) => hasOldMappings ||
+                (typeof dataSource === 'object' &&
+                    dataSource.mapping &&
+                    typeof dataSource.mapping === 'object' &&
+                    dataSource.mapping.apiVersion === '0.0.5'), false) ||
+                (Array.isArray(manifest.templates) &&
+                    manifest.templates.reduce((hasOldMappings, template) => hasOldMappings ||
+                        (typeof template === 'object' &&
+                            template.mapping &&
+                            typeof template.mapping === 'object' &&
+                            template.mapping.apiVersion === '0.0.5'), false))));
+    },
+    apply: async ({ manifestFile }) => {
+        // Make sure we catch all variants; we could load the manifest
+        // and replace the values in the data structures here; unfortunately
+        // writing that back to the file messes with the formatting more than
+        // we'd like; that's why for now, we use a simple patching approach
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp('apiVersion: 0.0.5', 'g'), 'apiVersion: 0.0.6');
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp("apiVersion: '0.0.5'", 'g'), "apiVersion: '0.0.6'");
+        await toolbox.patching.replace(manifestFile, 
+        // @ts-expect-error toolbox patching seems to accept RegExp
+        new RegExp('apiVersion: "0.0.5"', 'g'), 'apiVersion: "0.0.6"');
+    },
+};

package/dist/migrations/spec_version_0_0_2.js

@@ -0,0 +1,45 @@
+"use strict";
+/* eslint-disable */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toolbox = __importStar(require("gluegun"));
+const load_manifest_1 = require("./util/load-manifest");
+// Spec version to 0.0.2 uses top level templates. graph-cli no longer supports
+// 0.0.1 which used nested templates.
+exports.default = {
+    name: 'Bump manifest specVersion from 0.0.1 to 0.0.2',
+    predicate: async ({ manifestFile }) => {
+        const manifest = await (0, load_manifest_1.loadManifest)(manifestFile);
+        return (manifest &&
+            typeof manifest === 'object' &&
+            manifest.specVersion &&
+            manifest.specVersion === '0.0.1');
+    },
+    apply: async ({ manifestFile }) => {
+        await toolbox.patching.replace(manifestFile, 'specVersion: 0.0.1', 'specVersion: 0.0.2');
+        await toolbox.patching.replace(manifestFile, "specVersion: '0.0.1'", "specVersion: '0.0.2'");
+        await toolbox.patching.replace(manifestFile, 'specVersion: "0.0.1"', 'specVersion: "0.0.2"');
+    },
+};

package/dist/migrations/spec_version_0_0_3.js

@@ -0,0 +1,50 @@
+"use strict";
+/* eslint-disable */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toolbox = __importStar(require("gluegun"));
+const load_manifest_1 = require("./util/load-manifest");
+// Spec version 0.0.4 uses feature management, but features are
+// detected and validated by the graph-node instance during subgraph
+// deployment.
+//
+// Also, we skip spec version 0.0.3, which is considered invalid and
+// non-canonical.
+exports.default = {
+    name: 'Bump manifest specVersion from 0.0.2 to 0.0.4',
+    predicate: async ({ manifestFile }) => {
+        const manifest = await (0, load_manifest_1.loadManifest)(manifestFile);
+        return (manifest &&
+            typeof manifest === 'object' &&
+            manifest.specVersion &&
+            (manifest.specVersion === '0.0.2' || manifest.specVersion === '0.0.3'));
+    },
+    apply: async ({ manifestFile }) => {
+        await toolbox.patching.patch(manifestFile, {
+            insert: 'specVersion: 0.0.4',
+            replace: new RegExp(`specVersion: ['"]?0.0.[23]['"]?`),
+        });
+    },
+};

package/dist/migrations/util/load-manifest.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadManifest = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+async function loadManifest(manifestFile) {
+    if (manifestFile.match(/.js$/)) {
+        return require(path_1.default.resolve(manifestFile));
+    }
+    return js_yaml_1.default.safeLoad(await fs_extra_1.default.readFile(manifestFile, 'utf-8'));
+}
+exports.loadManifest = loadManifest;

package/dist/migrations/util/versions.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 });
+exports.getGraphTsVersion = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function getGraphTsVersion(sourceDir) {
+    let graphTsPath;
+    for (let dir = path_1.default.resolve(sourceDir); 
+    // Terminate after the root dir or when we have found node_modules
+    dir !== undefined; 
+    // Continue with the parent directory, terminate after the root dir
+    dir = path_1.default.dirname(dir) === dir ? undefined : path_1.default.dirname(dir)) {
+        const graphTsNodeModulesPath = path_1.default.join(dir, 'node_modules', '@graphprotocol', 'graph-ts');
+        if (fs_extra_1.default.existsSync(graphTsNodeModulesPath)) {
+            graphTsPath = graphTsNodeModulesPath;
+            // Loop until we find the first occurrence of graph-ts in node_modules
+            break;
+        }
+    }
+    const pkgJsonFile = path_1.default.join(graphTsPath, 'package.json');
+    const data = await fs_extra_1.default.readFile(pkgJsonFile);
+    const jsonData = JSON.parse(data.toString());
+    return jsonData.version;
+}
+exports.getGraphTsVersion = getGraphTsVersion;

package/dist/migrations.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyMigrations = void 0;
+const spinner_1 = require("./command-helpers/spinner");
+const MIGRATIONS = [
+    Promise.resolve().then(() => __importStar(require('./migrations/mapping_api_version_0_0_1'))),
+    Promise.resolve().then(() => __importStar(require('./migrations/mapping_api_version_0_0_2'))),
+    Promise.resolve().then(() => __importStar(require('./migrations/mapping_api_version_0_0_3'))),
+    Promise.resolve().then(() => __importStar(require('./migrations/mapping_api_version_0_0_4'))),
+    Promise.resolve().then(() => __importStar(require('./migrations/mapping_api_version_0_0_5'))),
+    Promise.resolve().then(() => __importStar(require('./migrations/spec_version_0_0_2'))),
+    Promise.resolve().then(() => __importStar(require('./migrations/spec_version_0_0_3'))),
+];
+const applyMigrations = async (options) => await (0, spinner_1.withSpinner)(`Apply migrations`, `Failed to apply migrations`, `Warnings while applying migraitons`, async (spinner) => {
+    await MIGRATIONS.reduce(async (previousPromise, migrationImport) => {
+        await previousPromise;
+        const { default: migration } = await migrationImport;
+        const skipHint = await migration.predicate(options);
+        if (typeof skipHint !== 'string' && skipHint) {
+            (0, spinner_1.step)(spinner, 'Apply migration:', migration.name);
+            await migration.apply(options);
+        }
+        else if (typeof skipHint === 'string') {
+            (0, spinner_1.step)(spinner, 'Skip migration:', `${migration.name} (${skipHint})`);
+        }
+        else {
+            (0, spinner_1.step)(spinner, 'Skip migration:', String(migration.name));
+        }
+    }, Promise.resolve());
+});
+exports.applyMigrations = applyMigrations;

package/dist/protocols/arweave/manifest.graphql

@@ -0,0 +1,57 @@
+# 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!
+  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 {
+  owner: String
+  startBlock: BigInt
+}
+
+type ContractMapping {
+  apiVersion: String!
+  language: String!
+  file: File!
+  entities: [String!]!
+  blockHandlers: [BlockHandler!]
+  transactionHandlers: [TransactionHandler!]
+}
+
+type BlockHandler {
+  handler: String!
+}
+
+type TransactionHandler {
+  handler: String!
+}
+
+type Graft {
+  base: String!
+  block: BigInt!
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapping = exports.source = void 0;
+const source = ({ contract }) => `
+      owner: '${contract}'`;
+exports.source = source;
+const mapping = () => `
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - Block
+        - Transaction
+      blockHandlers:
+        - handler: handleBlock
+      transactionHandlers:
+        - handler: handleTx
+      file: ./src/mapping.ts`;
+exports.mapping = mapping;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlaceholderHandlers = void 0;
+const generatePlaceholderHandlers = () => `
+  import { arweave, BigInt } from '@graphprotocol/graph-ts'
+  import { Block, Transaction } from '../generated/schema'
+
+  export function handleBlock(block: arweave.Block): void {
+    // Entities can be loaded from the store using a indepHash; this indepHash
+    // needs to be unique across all entities of the same type
+    let entity = Block.load(block.indepHash.toHexString())
+
+    // Entities only exist after they have been saved to the store;
+    // \`null\` checks allow to create entities on demand
+    if (!entity) {
+      entity = new Block(block.indepHash.toHexString());
+
+      // Entity fields can be set using simple assignments
+      entity.height = BigInt.fromU64(block.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.
+  }
+
+  export function handleTx(tb: arweave.TransactionWithBlockPtr): void {
+    const tx = tb.tx;
+    const entity = new Transaction(tx.id.toHexString());
+
+    entity.block = tb.block.indepHash;
+    entity.tx_id = tx.id;
+    entity.last_tx = tx.lastTx;
+    entity.owner = tx.owner;
+    entity.tags = saveTags(tx.id.toHexString(), tx.tags);
+    entity.data = tx.data;
+    entity.data_root = tx.dataRoot;
+    entity.data_size = tx.dataSize;
+    entity.target = tx.target;
+    entity.quantity = tx.quantity;
+    entity.signature = tx.signature;
+    entity.reward = tx.reward;
+
+    entity.save();
+  }
+`;
+exports.generatePlaceholderHandlers = generatePlaceholderHandlers;

package/dist/protocols/arweave/subgraph.js

@@ -0,0 +1,23 @@
+"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 ArweaveSubgraph {
+    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', 'transactionHandlers']);
+    }
+}
+exports.default = ArweaveSubgraph;

package/dist/protocols/contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });