@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/dist/protocols/ethereum/subgraph.js

@@ -0,0 +1,171 @@
+"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;
+};
+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"));
+const abi_1 = __importDefault(require("./abi"));
+const DataSourcesExtractor = __importStar(require("../../command-helpers/data-sources"));
+class EthereumSubgraph {
+    constructor(options = {}) {
+        this.manifest = options.manifest;
+        this.resolveFile = options.resolveFile;
+        this.protocol = options.protocol;
+    }
+    validateManifest() {
+        return this.validateAbis()
+            .concat(this.validateEvents())
+            .concat(this.validateCallFunctions());
+    }
+    validateAbis() {
+        const dataSourcesAndTemplates = DataSourcesExtractor.fromManifest(this.manifest, this.protocol);
+        return dataSourcesAndTemplates.reduce((errors, dataSourceOrTemplate) => errors.concat(this.validateDataSourceAbis(dataSourceOrTemplate.get('dataSource'), dataSourceOrTemplate.get('path'))), immutable_1.default.List());
+    }
+    validateDataSourceAbis(dataSource, path) {
+        // Validate that the the "source > abi" reference of all data sources
+        // points to an existing ABI in the data source ABIs
+        let abiName = dataSource.getIn(['source', 'abi']);
+        let abiNames = dataSource.getIn(['mapping', 'abis']).map(abi => abi.get('name'));
+        let nameErrors = abiNames.includes(abiName)
+            ? immutable_1.default.List()
+            : immutable_1.default.fromJS([
+                {
+                    path: [...path, 'source', 'abi'],
+                    message: `\
+ABI name '${abiName}' not found in mapping > abis.
+Available ABIs:
+${abiNames
+                        .sort()
+                        .map(name => `- ${name}`)
+                        .join('\n')}`,
+                },
+            ]);
+        // Validate that all ABI files are valid
+        let fileErrors = dataSource
+            .getIn(['mapping', 'abis'])
+            .reduce((errors, abi, abiIndex) => {
+            try {
+                abi_1.default.load(abi.get('name'), this.resolveFile(abi.get('file')));
+                return errors;
+            }
+            catch (e) {
+                return errors.push(immutable_1.default.fromJS({
+                    path: [...path, 'mapping', 'abis', abiIndex, 'file'],
+                    message: e.message,
+                }));
+            }
+        }, immutable_1.default.List());
+        return nameErrors.concat(fileErrors);
+    }
+    validateEvents() {
+        const dataSourcesAndTemplates = DataSourcesExtractor.fromManifest(this.manifest, this.protocol);
+        return dataSourcesAndTemplates.reduce((errors, dataSourceOrTemplate) => {
+            return errors.concat(this.validateDataSourceEvents(dataSourceOrTemplate.get('dataSource'), dataSourceOrTemplate.get('path')));
+        }, immutable_1.default.List());
+    }
+    validateDataSourceEvents(dataSource, path) {
+        let abi;
+        try {
+            // Resolve the source ABI name into a real ABI object
+            let abiName = dataSource.getIn(['source', 'abi']);
+            let abiEntry = dataSource
+                .getIn(['mapping', 'abis'])
+                .find(abi => abi.get('name') === abiName);
+            abi = abi_1.default.load(abiEntry.get('name'), this.resolveFile(abiEntry.get('file')));
+        }
+        catch (_) {
+            // Ignore errors silently; we can't really say anything about
+            // the events if the ABI can't even be loaded
+            return immutable_1.default.List();
+        }
+        // Obtain event signatures from the mapping
+        let manifestEvents = dataSource
+            .getIn(['mapping', 'eventHandlers'], immutable_1.default.List())
+            .map(handler => handler.get('event'));
+        // Obtain event signatures from the ABI
+        let abiEvents = abi.eventSignatures();
+        // Add errors for every manifest event signature that is not
+        // present in the ABI
+        return manifestEvents.reduce((errors, manifestEvent, index) => abiEvents.includes(manifestEvent)
+            ? errors
+            : errors.push(immutable_1.default.fromJS({
+                path: [...path, 'eventHandlers', index],
+                message: `\
+Event with signature '${manifestEvent}' not present in ABI '${abi.name}'.
+Available events:
+${abiEvents
+                    .sort()
+                    .map(event => `- ${event}`)
+                    .join('\n')}`,
+            })), immutable_1.default.List());
+    }
+    validateCallFunctions() {
+        return this.manifest
+            .get('dataSources')
+            .filter(dataSource => this.protocol.isValidKindName(dataSource.get('kind')))
+            .reduce((errors, dataSource, dataSourceIndex) => {
+            let path = ['dataSources', dataSourceIndex, 'callHandlers'];
+            let abi;
+            try {
+                // Resolve the source ABI name into a real ABI object
+                let abiName = dataSource.getIn(['source', 'abi']);
+                let abiEntry = dataSource
+                    .getIn(['mapping', 'abis'])
+                    .find(abi => abi.get('name') === abiName);
+                abi = abi_1.default.load(abiEntry.get('name'), this.resolveFile(abiEntry.get('file')));
+            }
+            catch (e) {
+                // Ignore errors silently; we can't really say anything about
+                // the call functions if the ABI can't even be loaded
+                return errors;
+            }
+            // Obtain event signatures from the mapping
+            let manifestFunctions = dataSource
+                .getIn(['mapping', 'callHandlers'], immutable_1.default.List())
+                .map(handler => handler.get('function'));
+            // Obtain event signatures from the ABI
+            let abiFunctions = abi.callFunctionSignatures();
+            // Add errors for every manifest event signature that is not
+            // present in the ABI
+            return manifestFunctions.reduce((errors, manifestFunction, index) => abiFunctions.includes(manifestFunction)
+                ? errors
+                : errors.push(immutable_1.default.fromJS({
+                    path: [...path, index],
+                    message: `\
+Call function with signature '${manifestFunction}' not present in ABI '${abi.name}'.
+Available call functions:
+${abiFunctions
+                        .sort()
+                        .map(tx => `- ${tx}`)
+                        .join('\n')}`,
+                })), errors);
+        }, immutable_1.default.List());
+    }
+    handlerTypes() {
+        return immutable_1.default.List(['blockHandlers', 'callHandlers', 'eventHandlers']);
+    }
+}
+exports.default = EthereumSubgraph;

package/dist/protocols/ethereum/type-generator.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const immutable_1 = __importDefault(require("immutable"));
+const prettier_1 = __importDefault(require("prettier"));
+const abi_1 = __importDefault(require("./abi"));
+const spinner_1 = require("../../command-helpers/spinner");
+const typescript_1 = require("../../codegen/typescript");
+const fs_1 = require("../../command-helpers/fs");
+class EthereumTypeGenerator {
+    constructor(options = {}) {
+        this.sourceDir = options.sourceDir;
+        this.outputDir = options.outputDir;
+    }
+    async loadABIs(subgraph) {
+        return await (0, spinner_1.withSpinner)('Load contract ABIs', 'Failed to load contract ABIs', `Warnings while loading contract ABIs`, async (spinner) => {
+            try {
+                return subgraph
+                    .get('dataSources')
+                    .reduce((abis, dataSource) => dataSource
+                    .getIn(['mapping', 'abis'])
+                    .reduce((abis, abi) => abis.push(this._loadABI(dataSource, abi.get('name'), abi.get('file'), spinner)), abis), immutable_1.default.List());
+            }
+            catch (e) {
+                throw Error(`Failed to load contract ABIs: ${e.message}`);
+            }
+        });
+    }
+    _loadABI(dataSource, name, maybeRelativePath, spinner) {
+        try {
+            if (this.sourceDir) {
+                let absolutePath = path_1.default.resolve(this.sourceDir, maybeRelativePath);
+                (0, spinner_1.step)(spinner, `Load contract ABI from`, (0, fs_1.displayPath)(absolutePath));
+                return { dataSource: dataSource, abi: abi_1.default.load(name, absolutePath) };
+            }
+            else {
+                return { dataSource: dataSource, abi: abi_1.default.load(name, maybeRelativePath) };
+            }
+        }
+        catch (e) {
+            throw Error(`Failed to load contract ABI: ${e.message}`);
+        }
+    }
+    async loadDataSourceTemplateABIs(subgraph) {
+        return await (0, spinner_1.withSpinner)(`Load data source template ABIs`, `Failed to load data source template ABIs`, `Warnings while loading data source template ABIs`, async (spinner) => {
+            let abis = [];
+            for (let template of subgraph.get('templates', immutable_1.default.List())) {
+                for (let abi of template.getIn(['mapping', 'abis'])) {
+                    abis.push(this._loadDataSourceTemplateABI(template, abi.get('name'), abi.get('file'), spinner));
+                }
+            }
+            return abis;
+        });
+    }
+    _loadDataSourceTemplateABI(template, name, maybeRelativePath, spinner) {
+        try {
+            if (this.sourceDir) {
+                let absolutePath = path_1.default.resolve(this.sourceDir, maybeRelativePath);
+                (0, spinner_1.step)(spinner, `Load data source template ABI from`, (0, fs_1.displayPath)(absolutePath));
+                return { template, abi: abi_1.default.load(name, absolutePath) };
+            }
+            else {
+                return { template, abi: abi_1.default.load(name, maybeRelativePath) };
+            }
+        }
+        catch (e) {
+            throw Error(`Failed to load data source template ABI: ${e.message}`);
+        }
+    }
+    generateTypesForABIs(abis) {
+        return (0, spinner_1.withSpinner)(`Generate types for contract ABIs`, `Failed to generate types for contract ABIs`, `Warnings while generating types for contract ABIs`, async (spinner) => {
+            return await Promise.all(abis.map(async (abi, name) => await this._generateTypesForABI(abi, spinner)));
+        });
+    }
+    async _generateTypesForABI(abi, spinner) {
+        try {
+            (0, spinner_1.step)(spinner, `Generate types for contract ABI:`, `${abi.abi.name} (${(0, fs_1.displayPath)(abi.abi.file)})`);
+            let codeGenerator = abi.abi.codeGenerator();
+            let code = prettier_1.default.format([
+                typescript_1.GENERATED_FILE_NOTE,
+                ...codeGenerator.generateModuleImports(),
+                ...codeGenerator.generateTypes(),
+            ].join('\n'), {
+                parser: 'typescript',
+            });
+            let outputFile = path_1.default.join(this.outputDir, abi.dataSource.get('name'), `${abi.abi.name}.ts`);
+            (0, spinner_1.step)(spinner, `Write types to`, (0, fs_1.displayPath)(outputFile));
+            await fs_extra_1.default.mkdirs(path_1.default.dirname(outputFile));
+            await fs_extra_1.default.writeFile(outputFile, code);
+        }
+        catch (e) {
+            throw Error(`Failed to generate types for contract ABI: ${e.message}`);
+        }
+    }
+    async generateTypesForDataSourceTemplateABIs(abis) {
+        return await (0, spinner_1.withSpinner)(`Generate types for data source template ABIs`, `Failed to generate types for data source template ABIs`, `Warnings while generating types for data source template ABIs`, async (spinner) => {
+            return await Promise.all(abis.map(async (abi, name) => await this._generateTypesForDataSourceTemplateABI(abi, spinner)));
+        });
+    }
+    async _generateTypesForDataSourceTemplateABI(abi, spinner) {
+        try {
+            (0, spinner_1.step)(spinner, `Generate types for data source template ABI:`, `${abi.template.get('name')} > ${abi.abi.name} (${(0, fs_1.displayPath)(abi.abi.file)})`);
+            let codeGenerator = abi.abi.codeGenerator();
+            let code = prettier_1.default.format([
+                typescript_1.GENERATED_FILE_NOTE,
+                ...codeGenerator.generateModuleImports(),
+                ...codeGenerator.generateTypes(),
+            ].join('\n'), {
+                parser: 'typescript',
+            });
+            let outputFile = path_1.default.join(this.outputDir, 'templates', abi.template.get('name'), `${abi.abi.name}.ts`);
+            (0, spinner_1.step)(spinner, `Write types to`, (0, fs_1.displayPath)(outputFile));
+            await fs_extra_1.default.mkdirs(path_1.default.dirname(outputFile));
+            await fs_extra_1.default.writeFile(outputFile, code);
+        }
+        catch (e) {
+            throw Error(`Failed to generate types for data source template ABI: ${e.message}`);
+        }
+    }
+}
+exports.default = EthereumTypeGenerator;

package/dist/protocols/index.js

@@ -0,0 +1,268 @@
+"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;
+};
+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"));
+const subgraph_1 = __importDefault(require("./arweave/subgraph"));
+const type_generator_1 = __importDefault(require("./ethereum/type-generator"));
+const template_1 = __importDefault(require("./ethereum/codegen/template"));
+const abi_1 = __importDefault(require("./ethereum/abi"));
+const subgraph_2 = __importDefault(require("./ethereum/subgraph"));
+const subgraph_3 = __importDefault(require("./near/subgraph"));
+const subgraph_4 = __importDefault(require("./cosmos/subgraph"));
+const subgraph_5 = __importDefault(require("./substreams/subgraph"));
+const contract_1 = __importDefault(require("./ethereum/contract"));
+const contract_2 = __importDefault(require("./near/contract"));
+const ArweaveManifestScaffold = __importStar(require("./arweave/scaffold/manifest"));
+const EthereumManifestScaffold = __importStar(require("./ethereum/scaffold/manifest"));
+const NearManifestScaffold = __importStar(require("./near/scaffold/manifest"));
+const CosmosManifestScaffold = __importStar(require("./cosmos/scaffold/manifest"));
+const SubstreamsManifestScaffold = __importStar(require("./substreams/scaffold/manifest"));
+const ArweaveMappingScaffold = __importStar(require("./arweave/scaffold/mapping"));
+const EthereumMappingScaffold = __importStar(require("./ethereum/scaffold/mapping"));
+const NearMappingScaffold = __importStar(require("./near/scaffold/mapping"));
+const CosmosMappingScaffold = __importStar(require("./cosmos/scaffold/mapping"));
+const debug_1 = __importDefault(require("../debug"));
+let protocolDebug = (0, debug_1.default)('graph-cli:protocol');
+class Protocol {
+    static fromDataSources(dataSourcesAndTemplates) {
+        const firstDataSourceKind = dataSourcesAndTemplates[0].kind;
+        return new Protocol(firstDataSourceKind);
+    }
+    name;
+    // TODO: should assert non null? see the constructor switch default case comment
+    config;
+    constructor(name) {
+        this.name = Protocol.normalizeName(name);
+        switch (this.name) {
+            case 'arweave':
+                this.config = arweaveProtocol;
+                break;
+            case 'cosmos':
+                this.config = cosmosProtocol;
+                break;
+            case 'ethereum':
+                this.config = ethereumProtocol;
+                break;
+            case 'near':
+                this.config = nearProtocol;
+                break;
+            case 'substreams':
+                this.config = substreamsProtocol;
+                break;
+            default:
+            // Do not throw when undefined, a better error message is printed after the constructor
+            // when validating the Subgraph itself
+        }
+    }
+    static availableProtocols() {
+        return immutable_1.default.fromJS({
+            // `ethereum/contract` is kept for backwards compatibility.
+            // New networks (or protocol perhaps) shouldn't have the `/contract` anymore (unless a new case makes use of it).
+            arweave: ['arweave'],
+            ethereum: ['ethereum', 'ethereum/contract'],
+            near: ['near'],
+            cosmos: ['cosmos'],
+            substreams: ['substreams'],
+        });
+    }
+    static availableNetworks() {
+        let networks = immutable_1.default.fromJS({
+            arweave: ['arweave-mainnet'],
+            ethereum: [
+                'mainnet',
+                'rinkeby',
+                'goerli',
+                'poa-core',
+                'poa-sokol',
+                'gnosis',
+                'matic',
+                'mumbai',
+                'fantom',
+                'fantom-testnet',
+                'bsc',
+                'chapel',
+                'clover',
+                'avalanche',
+                'fuji',
+                'celo',
+                'celo-alfajores',
+                'fuse',
+                'moonbeam',
+                'moonriver',
+                'mbase',
+                'arbitrum-one',
+                'arbitrum-rinkeby',
+                'optimism',
+                'optimism-kovan',
+                'aurora',
+                'aurora-testnet',
+            ],
+            near: ['near-mainnet', 'near-testnet'],
+            cosmos: [
+                'cosmoshub-4',
+                'theta-testnet-001',
+                'osmosis-1',
+                'osmo-test-4',
+                'juno-1',
+                'uni-3', // Juno testnet
+            ],
+        });
+        let allNetworks = [];
+        networks.forEach(value => {
+            allNetworks.push(...value);
+        });
+        networks = networks.set('substreams', allNetworks);
+        return networks;
+    }
+    static normalizeName(name) {
+        return Protocol.availableProtocols().findKey(possibleNames => {
+            return possibleNames.includes(name);
+        });
+    }
+    displayName() {
+        return this.config?.displayName;
+    }
+    // Receives a data source kind, and checks if it's valid
+    // for the given protocol instance (this).
+    isValidKindName(kind) {
+        return Protocol.availableProtocols()
+            .get(this.name, immutable_1.default.List())
+            .includes(kind);
+    }
+    hasABIs() {
+        return this.config.abi != null;
+    }
+    hasContract() {
+        return this.config.contract != null;
+    }
+    hasEvents() {
+        // A problem with hasEvents usage in the codebase is that it's almost every where
+        // where used, the ABI data is actually use after the conditional, so it seems
+        // both concept are related. So internally, we map to this condition.
+        return this.hasABIs();
+    }
+    hasTemplates() {
+        return this.config.getTemplateCodeGen != null;
+    }
+    hasDataSourceMappingFile() {
+        return this.getMappingScaffold() != null;
+    }
+    getTypeGenerator(options) {
+        if (this.config == null || this.config.getTypeGenerator == null) {
+            return null;
+        }
+        return this.config.getTypeGenerator(options);
+    }
+    getTemplateCodeGen(template) {
+        if (!this.hasTemplates()) {
+            throw new Error(`Template data sources with kind '${this.name}' are not supported yet`);
+        }
+        return this.config.getTemplateCodeGen?.(template);
+    }
+    getABI() {
+        return this.config.abi;
+    }
+    getSubgraph(options = {}) {
+        return this.config.getSubgraph({ ...options, protocol: this });
+    }
+    getContract() {
+        return this.config.contract;
+    }
+    getManifestScaffold() {
+        return this.config.manifestScaffold;
+    }
+    getMappingScaffold() {
+        return this.config.mappingScaffold;
+    }
+}
+exports.default = Protocol;
+const arweaveProtocol = {
+    displayName: 'Arweave',
+    abi: undefined,
+    contract: undefined,
+    getTemplateCodeGen: undefined,
+    getTypeGenerator: undefined,
+    getSubgraph(options) {
+        return new subgraph_1.default(options);
+    },
+    manifestScaffold: ArweaveManifestScaffold,
+    mappingScaffold: ArweaveMappingScaffold,
+};
+const cosmosProtocol = {
+    displayName: 'Cosmos',
+    abi: undefined,
+    contract: undefined,
+    getTemplateCodeGen: undefined,
+    getTypeGenerator: undefined,
+    getSubgraph(options) {
+        return new subgraph_4.default(options);
+    },
+    manifestScaffold: CosmosManifestScaffold,
+    mappingScaffold: CosmosMappingScaffold,
+};
+const ethereumProtocol = {
+    displayName: 'Ethereum',
+    abi: abi_1.default,
+    contract: contract_1.default,
+    getTemplateCodeGen(template) {
+        return new template_1.default(template);
+    },
+    getTypeGenerator(options) {
+        return new type_generator_1.default(options);
+    },
+    getSubgraph(options) {
+        return new subgraph_2.default(options);
+    },
+    manifestScaffold: EthereumManifestScaffold,
+    mappingScaffold: EthereumMappingScaffold,
+};
+const nearProtocol = {
+    displayName: 'NEAR',
+    abi: undefined,
+    contract: contract_2.default,
+    getTypeGenerator: undefined,
+    getTemplateCodeGen: undefined,
+    getSubgraph(options) {
+        return new subgraph_3.default(options);
+    },
+    manifestScaffold: NearManifestScaffold,
+    mappingScaffold: NearMappingScaffold,
+};
+const substreamsProtocol = {
+    displayName: 'Substreams',
+    abi: undefined,
+    contract: undefined,
+    getTypeGenerator: undefined,
+    getTemplateCodeGen: undefined,
+    getSubgraph(options) {
+        return new subgraph_5.default(options);
+    },
+    manifestScaffold: SubstreamsManifestScaffold,
+    mappingScaffold: undefined,
+};
+protocolDebug('Available networks %M', Protocol.availableNetworks());

package/dist/protocols/ipfs/codegen/file_template.js

@@ -0,0 +1,50 @@
+"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 });
+const tsCodegen = __importStar(require("../../../codegen/typescript"));
+class IpfsFileTemplateCodeGen {
+    constructor(template) {
+        this.template = template;
+    }
+    generateModuleImports() {
+        return [];
+    }
+    generateCreateMethod() {
+        const name = this.template.get('name');
+        return tsCodegen.staticMethod('create', [tsCodegen.param('cid', tsCodegen.namedType('string'))], tsCodegen.namedType('void'), `
+      DataSourceTemplate.create('${name}', [cid])
+      `);
+    }
+    generateCreateWithContextMethod() {
+        const name = this.template.get('name');
+        return tsCodegen.staticMethod('createWithContext', [
+            tsCodegen.param('cid', tsCodegen.namedType('string')),
+            tsCodegen.param('context', tsCodegen.namedType('DataSourceContext')),
+        ], tsCodegen.namedType('void'), `
+      DataSourceTemplate.createWithContext('${name}', [cid], context)
+      `);
+    }
+}
+exports.default = IpfsFileTemplateCodeGen;

package/dist/protocols/near/contract.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MINIMUM_ACCOUNT_ID_LENGTH = 2;
+const MAXIMUM_ACCOUNT_ID_LENGTH = 64;
+const RULES_URL = 'https://docs.near.org/docs/concepts/account#account-id-rules';
+class NearContract {
+    account;
+    static identifierName() {
+        return 'account';
+    }
+    constructor(account) {
+        this.account = account;
+    }
+    validateLength(value) {
+        return (value.length >= MINIMUM_ACCOUNT_ID_LENGTH &&
+            value.length <= MAXIMUM_ACCOUNT_ID_LENGTH);
+    }
+    validateFormat(value) {
+        const pattern = /^(([a-z\d]+[\-_])*[a-z\d]+\.)*([a-z\d]+[\-_])*[a-z\d]+$/;
+        return pattern.test(value);
+    }
+    validate() {
+        if (!this.validateLength(this.account)) {
+            return {
+                valid: false,
+                error: `Account must be between '${MINIMUM_ACCOUNT_ID_LENGTH}' and '${MAXIMUM_ACCOUNT_ID_LENGTH}' characters, see ${RULES_URL}`,
+            };
+        }
+        if (!this.validateFormat(this.account)) {
+            return {
+                valid: false,
+                error: `Account must conform to the rules on ${RULES_URL}`,
+            };
+        }
+        return {
+            valid: true,
+            error: null,
+        };
+    }
+}
+exports.default = NearContract;