@graphprotocol/graph-cli 0.94.0 → 0.95.0-alpha-20250122003255-e449cf69b90cf3813ea73e4b363230c38dc9257f

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @graphprotocol/graph-cli
 
+## 0.95.0-alpha-20250122003255-e449cf69b90cf3813ea73e4b363230c38dc9257f
+
+### Minor Changes
+
+- [#1899](https://github.com/graphprotocol/graph-tooling/pull/1899)
+  [`8cdaf31`](https://github.com/graphprotocol/graph-tooling/commit/8cdaf31e78c7fb7bf7ef4f5380d0c72b2a05b08d)
+  Thanks [@0237h](https://github.com/0237h)! - Add support for Sourcify contract information lookup
+
+### Patch Changes
+
+- [#1903](https://github.com/graphprotocol/graph-tooling/pull/1903)
+  [`bcaad5e`](https://github.com/graphprotocol/graph-tooling/commit/bcaad5e077e485224c06842491145d05215f4c0e)
+  Thanks [@0237h](https://github.com/0237h)! - Fix `import.meta.url` not being parsed as path
+  properly
+
 ## 0.94.0
 
 ### Minor Changes

package/dist/command-helpers/contracts.d.ts

@@ -10,5 +10,10 @@ export declare class ContractService {
     getABI(ABICtor: typeof ABI, networkId: string, address: string): Promise<ABI>;
     getStartBlock(networkId: string, address: string): Promise<string>;
     getContractName(networkId: string, address: string): Promise<string>;
+    getFromSourcify(ABICtor: typeof ABI, networkId: string, address: string): Promise<{
+        abi: ABI;
+        startBlock: string;
+        name: string;
+    } | null>;
     private fetchTransactionByHash;
 }

package/dist/command-helpers/contracts.js

@@ -122,6 +122,45 @@ export class ContractService {
         }
         throw new Error(`Failed to fetch contract name for ${address}`);
     }
+    async getFromSourcify(ABICtor, networkId, address) {
+        try {
+            const network = this.registry.getNetworkById(networkId);
+            if (!network)
+                throw new Error(`Invalid network ${networkId}`);
+            if (!network.caip2Id.startsWith('eip155'))
+                throw new Error(`Invalid chainId, Sourcify API only supports EVM chains`);
+            const chainId = network.caip2Id.split(':')[1];
+            const url = `https://sourcify.dev/server/files/any/${chainId}/${address}`;
+            const json = await (await fetch(url).catch(error => {
+                throw new Error(`Sourcify API is unreachable: ${error}`);
+            })).json();
+            if (json) {
+                if ('error' in json)
+                    throw new Error(`Sourcify API error: ${json.error}`);
+                let metadata = json.files.find(e => e.name === 'metadata.json')?.content;
+                if (!metadata)
+                    throw new Error('Contract is missing metadata');
+                const tx_hash = json.files.find(e => e.name === 'creator-tx-hash.txt')?.content;
+                if (!tx_hash)
+                    throw new Error('Contract is missing tx creation hash');
+                const tx = await this.fetchTransactionByHash(networkId, tx_hash);
+                if (!tx?.blockNumber)
+                    throw new Error(`Can't fetch blockNumber from tx: ${JSON.stringify(tx)}`);
+                metadata = JSON.parse(metadata);
+                const contractName = Object.values(metadata.settings.compilationTarget)[0];
+                return {
+                    abi: new ABICtor(contractName, undefined, immutable.fromJS(metadata.output.abi)),
+                    startBlock: Number(tx.blockNumber).toString(),
+                    name: contractName,
+                };
+            }
+            throw new Error(`No result: ${JSON.stringify(json)}`);
+        }
+        catch (error) {
+            logger(`Failed to fetch from Sourcify: ${error}`);
+        }
+        return null;
+    }
     async fetchTransactionByHash(networkId, txHash) {
         const urls = this.getRpcUrls(networkId);
         if (!urls.length) {

package/dist/command-helpers/contracts.test.js

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vitest';
+import EthereumABI from '../protocols/ethereum/abi.js';
 import { ContractService } from './contracts.js';
 import { loadRegistry } from './registry.js';
 // An object with some test cases for contract deployment block numbers
@@ -79,16 +80,76 @@ const TEST_CONTRACT_START_BLOCKS = {
     // clover: {
     // },
 };
-describe('getStartBlockForContract', { sequential: true }, async () => {
+const TEST_SOURCIFY_CONTRACT_INFO = {
+    mainnet: {
+        '0xc2EdaD668740f1aA35E4D8f227fB8E17dcA888Cd': {
+            name: 'MasterChef',
+            startBlock: 10_736_242,
+        },
+    },
+    optimism: {
+        '0xc35DADB65012eC5796536bD9864eD8773aBc74C4': {
+            name: 'BentoBoxV1',
+            startBlock: 7_019_815,
+        },
+    },
+    wax: {
+        account: {
+            name: null,
+            startBlock: null,
+        },
+    },
+    'non-existing chain': {
+        '0x0000000000000000000000000000000000000000': {
+            name: null,
+            startBlock: null,
+        },
+    },
+};
+// Retry helper with configurable number of retries
+async function retry(operation, maxRetries = 3, sleepMs = 5000) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxRetries - 1) {
+                await new Promise(resolve => setTimeout(resolve, sleepMs));
+            }
+        }
+    }
+    throw lastError;
+}
+describe('getStartBlockForContract', { concurrent: true }, async () => {
     const registry = await loadRegistry();
     const contractService = new ContractService(registry);
     for (const [network, contracts] of Object.entries(TEST_CONTRACT_START_BLOCKS)) {
         for (const [contract, startBlockExp] of Object.entries(contracts)) {
-            test(`Returns the start block ${network} ${contract} ${startBlockExp}`, async () => {
-                //loop through the TEST_CONTRACT_START_BLOCKS object and test each network
-                const startBlock = await contractService.getStartBlock(network, contract);
+            test(`Returns the start block ${network} ${contract} ${startBlockExp}`, { timeout: 50_000 }, async ({ expect }) => {
+                const startBlock = await retry(() => contractService.getStartBlock(network, contract), 10);
                 expect(parseInt(startBlock)).toBe(startBlockExp);
-            }, { timeout: 10_000 });
+            });
+        }
+    }
+});
+describe('getFromSourcifyForContract', { concurrent: true }, async () => {
+    const registry = await loadRegistry();
+    const contractService = new ContractService(registry);
+    for (const [networkId, contractInfo] of Object.entries(TEST_SOURCIFY_CONTRACT_INFO)) {
+        for (const [contract, t] of Object.entries(contractInfo)) {
+            test(`Returns contract information ${networkId} ${contract} ${t.name} ${t.startBlock}`, { timeout: 50_000 }, async () => {
+                const result = await retry(() => contractService.getFromSourcify(EthereumABI, networkId, contract));
+                if (t.name === null && t.startBlock === null) {
+                    expect(result).toBeNull();
+                }
+                else {
+                    // Only check name and startBlock, omit API property from Sourcify results
+                    const { name, startBlock } = result;
+                    expect(t).toEqual({ name, startBlock: parseInt(startBlock) });
+                }
+            });
         }
     }
 });

package/dist/command-helpers/network.test.js

@@ -1,9 +1,10 @@
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import * as toolbox from 'gluegun';
 import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 import yaml from 'yaml';
 import { initNetworksConfig, updateSubgraphNetwork } from './network.js';
-const SUBGRAPH_PATH_BASE = path.join(`${process.platform === 'win32' ? '' : '/'}${/file:\/{2,3}(.+)\/[^/]/.exec(import.meta.url)[1]}`, '..', '..', '..', '..', 'examples', 'example-subgraph');
+const SUBGRAPH_PATH_BASE = path.join(fileURLToPath(import.meta.url), '..', '..', '..', '..', '..', 'examples', 'example-subgraph');
 describe('initNetworksConfig', () => {
     beforeAll(async () => {
         await initNetworksConfig(SUBGRAPH_PATH_BASE, 'address');

package/dist/commands/add.js

@@ -58,10 +58,17 @@ export default class AddCommand extends Command {
             this.warn('`localhost` network detected, prompting user for inputs');
         const registry = await loadRegistry();
         const contractService = new ContractService(registry);
+        const sourcifyContractInfo = await contractService.getFromSourcify(EthereumABI, network, address);
         let startBlock = startBlockFlag ? parseInt(startBlockFlag).toString() : startBlockFlag;
         let contractName = contractNameFlag || DEFAULT_CONTRACT_NAME;
         let ethabi = null;
-        if (abi) {
+        if (sourcifyContractInfo) {
+            startBlock ??= sourcifyContractInfo.startBlock;
+            contractName =
+                contractName == DEFAULT_CONTRACT_NAME ? sourcifyContractInfo.name : contractName;
+            ethabi ??= sourcifyContractInfo.abi;
+        }
+        if (!ethabi && abi) {
             ethabi = EthereumABI.load(contractName, abi);
         }
         else {

package/dist/commands/init.js

@@ -18,6 +18,7 @@ import { withSpinner } from '../command-helpers/spinner.js';
 import { getSubgraphBasename } from '../command-helpers/subgraph.js';
 import { GRAPH_CLI_SHARED_HEADERS } from '../constants.js';
 import debugFactory from '../debug.js';
+import EthereumABI from '../protocols/ethereum/abi.js';
 import Protocol from '../protocols/index.js';
 import { abiEvents } from '../scaffold/schema.js';
 import Schema from '../schema.js';
@@ -154,6 +155,7 @@ export default class InitCommand extends Command {
         if ((fromContract || spkgPath) && protocol && subgraphName && directory && network && node) {
             const registry = await loadRegistry();
             const contractService = new ContractService(registry);
+            const sourcifyContractInfo = await contractService.getFromSourcify(EthereumABI, network, fromContract);
             if (!protocolChoices.includes(protocol)) {
                 this.error(`Protocol '${protocol}' is not supported, choose from these options: ${protocolChoices.join(', ')}`, { exit: 1 });
             }
@@ -170,7 +172,9 @@ export default class InitCommand extends Command {
                 }
                 else {
                     try {
-                        abi = await contractService.getABI(ABI, network, fromContract);
+                        abi = sourcifyContractInfo
+                            ? sourcifyContractInfo.abi
+                            : await contractService.getABI(ABI, network, fromContract);
                     }
                     catch (e) {
                         this.exit(1);
@@ -462,11 +466,21 @@ async function processInitForm({ abi: initAbi, abiPath: initAbiPath, directory:
                     source = address;
                     return address;
                 }
+                const sourcifyContractInfo = await contractService.getFromSourcify(EthereumABI, network.id, address);
+                if (sourcifyContractInfo) {
+                    initStartBlock ??= sourcifyContractInfo.startBlock;
+                    initContractName ??= sourcifyContractInfo.name;
+                    initAbi ??= sourcifyContractInfo.abi;
+                    initDebugger.extend('processInitForm')("infoFromSourcify: '%s'/'%s'", initStartBlock, initContractName);
+                }
                 // If ABI is not provided, try to fetch it from Etherscan API
                 if (protocolInstance.hasABIs() && !initAbi) {
                     abiFromApi = await retryWithPrompt(() => withSpinner('Fetching ABI from contract API...', 'Failed to fetch ABI', 'Warning fetching ABI', () => contractService.getABI(protocolInstance.getABI(), network.id, address)));
                     initDebugger.extend('processInitForm')("abiFromEtherscan len: '%s'", abiFromApi?.name);
                 }
+                else {
+                    abiFromApi = initAbi;
+                }
                 // If startBlock is not provided, try to fetch it from Etherscan API
                 if (!initStartBlock) {
                     startBlock = await retryWithPrompt(() => withSpinner('Fetching start block from contract API...', 'Failed to fetch start block', 'Warning fetching start block', () => contractService.getStartBlock(network.id, address)));

package/dist/commands/local.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import http from 'node:http';
 import net from 'node:net';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import compose from 'docker-compose';
 import { filesystem, patching } from 'gluegun';
 import stripAnsi from 'strip-ansi';
@@ -67,7 +68,7 @@ export default class LocalCommand extends Command {
         const skipWaitForEthereum = skipWaitForEthereumTypo || skipWaitForEthereumGood;
         // Obtain the Docker Compose file for services that the tests run against
         const composeFile = composeFileFlag ||
-            path.join(`${process.platform === 'win32' ? '' : '/'}${/file:\/{2,3}(.+)\/[^/]/.exec(import.meta.url)[1]}`, '..', '..', 'resources', 'test', standaloneNode ? 'docker-compose-standalone-node.yml' : 'docker-compose.yml');
+            path.join(fileURLToPath(import.meta.url), '..', '..', '..', 'resources', 'test', standaloneNode ? 'docker-compose-standalone-node.yml' : 'docker-compose.yml');
         if (!filesystem.exists(composeFile)) {
             this.error(`Docker Compose file "${composeFile}" not found`, { exit: 1 });
         }

package/dist/subgraph.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import fs from 'fs-extra';
 import * as graphql from 'graphql/language/index.js';
 import immutable from 'immutable';
@@ -31,7 +32,7 @@ export default class Subgraph {
             ]);
         }
         // Parse the default subgraph schema
-        const schema = graphql.parse(await fs.readFile(path.join(`${process.platform === 'win32' ? '' : '/'}${/file:\/{2,3}(.+)\/[^/]/.exec(import.meta.url)[1]}`, 'protocols', 
+        const schema = graphql.parse(await fs.readFile(path.join(fileURLToPath(import.meta.url), '..', 'protocols', 
         // TODO: substreams/triggers is a special case, should be handled better
         protocol.name === 'substreams/triggers' ? 'substreams' : protocol.name, `manifest.graphql`), 'utf-8'));
         // Obtain the root `SubgraphManifest` type from the schema

package/dist/version.js

@@ -1,9 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 const packageJson = JSON.parse(fs
     .readFileSync(
 // works even when bundled/built because the path to package.json is the same
-path.join(`${process.platform === 'win32' ? '' : '/'}${/file:\/{2,3}(.+)\/[^/]/.exec(import.meta.url)[1]}`, '..', 'package.json'))
+path.join(fileURLToPath(import.meta.url), '..', '..', 'package.json'))
     .toString());
 export const version = packageJson.version;
 export const nodeVersion = (packageJson.engines?.node ?? '');

package/oclif.manifest.json

@@ -1011,5 +1011,5 @@
       ]
     }
   },
-  "version": "0.94.0"
+  "version": "0.95.0-alpha-20250122003255-e449cf69b90cf3813ea73e4b363230c38dc9257f"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.94.0",
+  "version": "0.95.0-alpha-20250122003255-e449cf69b90cf3813ea73e4b363230c38dc9257f",
   "type": "module",
   "description": "CLI for building for and deploying to The Graph",
   "license": "(Apache-2.0 OR MIT)",
@@ -45,7 +45,7 @@
     "prettier": "3.4.2",
     "semver": "7.6.3",
     "tmp-promise": "3.0.3",
-    "undici": "7.1.1",
+    "undici": "7.2.3",
     "web3-eth-abi": "4.4.1",
     "yaml": "2.6.1"
   },