@solidusnetwork/hardhat-deploy-metadata 1.0.8

package/.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "Debug Mocha Tests",
+        "type": "node",
+        "request": "launch",
+        // Points to the Mocha executable in node_modules
+        "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+        "args": [
+          // Any glob or file path pattern to find your tests
+          "test/**/*.js",
+          // Increase timeout for slower tests
+          "--timeout",
+          "40000",
+          // Show colors in the console
+          "--colors"
+        ],
+        // Use an integrated terminal so you can see interactive logs
+        "console": "integratedTerminal",
+        // Ensure we are in the root of the plugin workspace
+        "cwd": "${workspaceFolder}"
+      }
+    ]
+  }

package/README.md

@@ -0,0 +1,31 @@
+# @solidusnetwork/hardhat-deploy-metadata
+
+A Hardhat plugin that allows users to push contract metadata to IPFS.
+
+## Installation
+
+```bash
+npm install @solidusnetwork/hardhat-deploy-metadata
+```
+
+## Usage
+
+In `hardhat.config.js`:
+
+```js
+require("@solidusnetwork/hardhat-deploy-metadata");
+```
+
+In your deploy script:
+
+```js
+const { deployMetadata } = require("hardhat");
+
+const ipfsHash = await deployMetadata.pushMetadataToIPFS("ContractName");
+
+const factory = new solidus.ContractFactory(contract.abi, contract.bytecode, wallet, ipfsHash);
+```
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,168 @@
+const fs = require("fs");
+const path = require("path");
+const { parseFullyQualifiedName } = require("hardhat/utils/contract-names");
+const Hash = require('ipfs-only-hash')
+const CBOR = require('cbor-x')
+const bs58 = require('bs58')
+const { splitAuxdata, AuxdataStyle } = require('@ethereum-sourcify/bytecode-utils');
+const { arrayify } = require('@ethersproject/bytes')
+const { extendEnvironment } = require("hardhat/config");
+const IPFS_URL = 'https://ipfs.solidus.network/api/v0'
+
+async function pushMetadataToIPFS(hre, contractName) {
+
+    // Load the artifact for the specified contract
+    const { artifacts } = hre; // The Hardhat 'artifacts' object
+    const artifact = await artifacts.readArtifact(contractName);
+    const ipfsHash = await pushMetadataToIPFSWithBytecode(hre, artifact.deployedBytecode)
+    return ipfsHash
+  }
+
+  async function pushMetadataToIPFSWithBytecode(hre, bytecode) {
+    const { artifacts } = hre; // The Hardhat 'artifacts' object
+
+    let metadataSections = decodeMultipleMetadataSections(bytecode)
+  
+    let ipfsEntries = []
+    const fqNames = await artifacts.getAllFullyQualifiedNames();
+    for (let fqn of fqNames) {
+      const buildInfo = await artifacts.getBuildInfo(fqn);
+      const { sourceName, contractName: name } = parseFullyQualifiedName(fqn);
+      const contractOutput = buildInfo.output.contracts[sourceName][name];
+      if (!contractOutput) {
+        throw new Error(`CompilerOutputContract not found for ${name}.`);
+      }
+      const hash = await Hash.of(contractOutput.metadata)
+      for (let metadata of metadataSections) {
+        if (hash === metadata.ipfs) {
+            ipfsEntries.push({ipfs: metadata.ipfs, name, metadata: contractOutput.metadata})
+        }
+      }
+    }
+    if (ipfsEntries.length === 0) {
+      throw new Error(
+        "Hardhat plugin error: No IPFS hash found in bytecode metadata. You must set `bytecodeHash: 'ipfs'` in your hardhat.config.js compiler settings:\n\n" +
+        "  solidity: {\n" +
+        "    compilers: [\n" +
+        "      {\n" +
+        "        version: '0.8.19',\n" +
+        "        settings: {\n" +
+        "          metadata: {\n" +
+        "            bytecodeHash: 'ipfs',\n" +
+        "            ...\n" +
+        "          }\n" +
+        "        }\n" +
+        "      }\n" +
+        "    ]\n" +
+        "  }"
+        );
+    }
+    const { create } = await import('kubo-rpc-client')
+    const client = create({
+      url: IPFS_URL,
+    });
+    try {
+      for (let data of ipfsEntries) {
+        const { cid } = await client.add(data.metadata);
+        await client.pin.add(cid);
+        console.log('File added with CID:', cid.toString());
+        console.log("Original IPFS hash found in bytecode:", data.ipfs);
+        if(data.ipfs !== cid.toString()) {
+          throw new Error("IPFS hash in bytecode does not match the CID of the added metadata, want " + data.ipfs + " got " + cid.toString())
+        }
+        const outputPath = path.join(
+          hre.config.paths.root,
+          "metadata",
+          `${data.name}_metadata.json`
+        );
+        const outputDir = path.dirname(outputPath);
+        fs.mkdirSync(outputDir, { recursive: true });
+        fs.writeFileSync(outputPath, JSON.stringify(data.metadata, null, 2));
+  
+        console.log(`Metadata JSON for ${data.name} saved to ${outputPath}`);
+      }
+  
+    } catch (error) {
+      console.error('Error adding file:', error);
+      return ""
+    }
+    return ipfsEntries[0].ipfs
+  }
+  
+  const decodeMultipleMetadataSections = (bytecode) => {
+    if (!bytecode || bytecode.length === 0) {
+        throw new Error("Bytecode cannot be empty");
+    }
+    bytecode = ensureHexPrefix(bytecode);
+  
+    const metadataSections = [];
+    let remainingBytecode = bytecode;
+  
+    while (remainingBytecode.length > 0) {
+      try {
+        const [executionBytecode, auxdata] = splitAuxdata(remainingBytecode, AuxdataStyle.SOLIDITY);
+  
+        if (auxdata) {
+          const decodedMetadata = CBOR.decode(arrayify(`0x${auxdata}`));
+          metadataSections.push(decodedMetadata);
+          remainingBytecode = executionBytecode;
+        } else {
+          break;
+        }
+      } catch (error) {
+        console.log(error)
+        break;
+      }
+    }
+  
+    return metadataSections.map((metadata) => ({
+      ...metadata,
+      ipfs: metadata.ipfs ? bs58.default.encode(metadata.ipfs) : undefined,
+    }));
+  };
+  const ensureHexPrefix = (bytecode) => {
+    return bytecode.startsWith('0x') ? bytecode : `0x${bytecode}`;
+  };
+
+  // Extend Hardhat's environment
+extendEnvironment((hre) => {
+    // attach the function to the HRE
+    hre.deployMetadata = {
+      pushMetadataToIPFS: (contractName) => pushMetadataToIPFS(hre, contractName),
+      pushMetadataToIPFSWithBytecode: (bytecode) => pushMetadataToIPFSWithBytecode(hre, bytecode),
+    };
+  })
+
+
+function ensureBytecodeHashIsIPFS(hre) {
+    // Read the Hardhat config
+    const compilers = hre.config.solidity.compilers || [];
+
+    // Check each compiler’s settings
+    const hasIPFSBytecode = compilers.some((compiler) => {
+        const settings = compiler.settings || {};
+        const metadata = settings.metadata || {};
+        return metadata.bytecodeHash === 'ipfs';
+    });
+
+    if (!hasIPFSBytecode) {
+        throw new Error(
+        "Hardhat plugin error: You must set `bytecodeHash: 'ipfs'` in your hardhat.config.js compiler settings:\n\n" +
+        "  solidity: {\n" +
+        "    compilers: [\n" +
+        "      {\n" +
+        "        version: '0.8.19',\n" +
+        "        settings: {\n" +
+        "          metadata: {\n" +
+        "            bytecodeHash: 'ipfs',\n" +
+        "            ...\n" +
+        "          }\n" +
+        "        }\n" +
+        "      }\n" +
+        "    ]\n" +
+        "  }"
+        );
+    }
+  }
+
+module.exports.pushMetadataToIPFS = pushMetadataToIPFS;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@solidusnetwork/hardhat-deploy-metadata",
+  "version": "1.0.8",
+  "description": "A Hardhat plugin that allows users to push contract metadata to IPFS.",
+  "main": "index.js",
+  "author": "Solidus Network",
+  "license": "MIT",
+  "keywords": [
+    "hardhat",
+    "plugin",
+    "ipfs",
+    "solidity",
+    "metadata",
+    "solidus"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solidus-network/hardhat-deploy-metadata.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "mocha --timeout 40000"
+  },
+  "peerDependencies": {
+    "hardhat": "^2.22.0"
+  },
+  "dependencies": {
+    "@ethereum-sourcify/bytecode-utils": "1.3.1",
+    "@ethersproject/bytes": "^5.7.0",
+    "@openzeppelin/contracts": "^5.0.0",
+    "arrayify": "^1.0.0",
+    "bs58": "^6.0.0",
+    "cbor-x": "^1.6.0",
+    "chai": "^4.1.2",
+    "crypto": "^1.0.1",
+    "dotenv": "^16.4.5",
+    "hardhat": "^2.22.0",
+    "ipfs-only-hash": "^4.0.0",
+    "kubo-rpc-client": "^5.0.2",
+    "mocha": "^11.0.1"
+  },
+  "devDependencies": {
+    "eslint": "^8.48.0"
+  }
+}

package/test/helpers.js

@@ -0,0 +1,28 @@
+const path = require("path");
+const fs = require("fs-extra");
+const { resetHardhatContext } = require("hardhat/plugins-testing");
+
+function useEnvironment(projectSubdir) {
+  beforeEach("Loading hardhat environment", function () {
+    const projectPath = path.join(__dirname, projectSubdir);
+    if (!fs.existsSync(projectPath)) {
+      throw new Error(`Test project folder '${projectSubdir}' not found in test/`);
+    }
+
+    // Change directory into the test fixture project
+    process.chdir(projectPath);
+    // Clear any require cache that might be left over
+    resetHardhatContext();
+
+    // Load a new Hardhat instance from this fixture
+    this.env = require("hardhat");
+  });
+
+  afterEach("Reset hardhat context", function () {
+    resetHardhatContext();
+    // Move back out to the main plugin directory
+    process.chdir(path.join(__dirname, "..", ".."));
+  });
+}
+
+module.exports = { useEnvironment };

package/test/ipfs-project/contracts/TestContract.sol

@@ -0,0 +1,7 @@
+pragma solidity ^0.8.20;
+
+contract TestContract {
+    function helloWorld() public pure returns (string memory) {
+        return "Hello World";
+    }
+}

package/test/ipfs-project/hardhat.config.js

@@ -0,0 +1,18 @@
+require('../../index.js');
+
+module.exports = {
+    solidity: {
+      compilers: [
+        {
+          version: "0.8.20",
+          settings: {
+            optimizer: { enabled: false },
+            evmVersion: 'london',
+            metadata: {
+              bytecodeHash: 'ipfs',
+            }
+          }
+        }
+      ]
+    }
+  };

package/test/no-ipfs-project/contracts/TestContract.sol

@@ -0,0 +1,7 @@
+pragma solidity ^0.8.20;
+
+contract TestContract {
+    function helloWorld() public pure returns (string memory) {
+        return "Hello World";
+    }
+}

package/test/no-ipfs-project/hardhat.config.js

@@ -0,0 +1,18 @@
+require('../../index.js');
+
+module.exports = {
+    solidity: {
+      compilers: [
+        {
+          version: "0.8.20",
+          settings: {
+            optimizer: { enabled: false },
+            metadata: {
+              useLiteralContent: true
+            },
+            evmVersion: 'london',
+          }
+        }
+      ]
+    }
+  };

package/test/test-plugin.js

@@ -0,0 +1,65 @@
+const { expect } = require("chai");
+const { useEnvironment } = require("./helpers");
+
+describe("Hardhat IPFS Metadata Plugin", function () {
+  // 1) Test using a project that DOES have `bytecodeHash: "ipfs"`
+  describe("when using the ipfs-project fixture", function () {
+    useEnvironment("ipfs-project");
+    it("should attach 'deployMetadata.pushMetadataToIPFS' to the Hardhat environment", function () {
+      // this.env is the Hardhat Runtime Environment loaded from helpers.js
+      expect(this.env.deployMetadata).to.be.an("object");
+      expect(this.env.deployMetadata.pushMetadataToIPFS).to.be.a("function");
+      expect(this.env.deployMetadata.pushMetadataToIPFSWithBytecode).to.be.a("function");
+    });
+
+    it("should not throw an error for missing 'bytecodeHash'", async function () {
+      // In the fixture, we set 'bytecodeHash' to 'ipfs' so it should pass.
+      // Let's compile a sample contract to ensure everything runs.
+      await this.env.run("compile");
+
+      // If there's a contract named "TestContract", let's call the plugin function
+      const ipfsHash = await this.env.deployMetadata.pushMetadataToIPFS("TestContract");
+
+      // The plugin returns the IPFS hash from the metadata in the bytecode
+      expect(ipfsHash).to.be.a("string");
+      expect(ipfsHash.length).to.be.equal(46);
+      console.log(`Retrieved IPFS hash: ${ipfsHash}`);
+    });
+
+    it("should deploy metadata to IPFS from provided bytecode", async function () {
+      // In the fixture, we set 'bytecodeHash' to 'ipfs' so it should pass.
+      // Let's compile a sample contract to ensure everything runs.
+      await this.env.run("compile");
+      
+      // If there's a contract named "TestContract", let's call the plugin function
+      const { artifacts } = this.env; // The Hardhat 'artifacts' object
+      const artifact = await artifacts.readArtifact("TestContract");
+      const ipfsHash = await this.env.deployMetadata.pushMetadataToIPFSWithBytecode(artifact.deployedBytecode);
+
+      // The plugin returns the IPFS hash from the metadata in the bytecode
+      expect(ipfsHash).to.be.a("string");
+      expect(ipfsHash.length).to.be.equal(46);
+      console.log(`Retrieved IPFS hash: ${ipfsHash}`);
+    });
+  });
+
+  // 2) Optionally, test a fixture that does NOT have 'bytecodeHash' set
+  //    to ensure your plugin properly throws an error.
+  /*describe("when using a project with no ipfs setting", function () {
+    // Suppose you have another fixture called "no-ipfs-project"
+    // that sets `bytecodeHash: "none"` or leaves it out.
+    useEnvironment("no-ipfs-project");
+
+    it("should throw an error if 'bytecodeHash' is not set to 'ipfs'", async function () {
+      let errorThrown = false;
+      try {
+        await this.env.run("compile");
+        await this.env.deployMetadata.pushMetadataToIPFS("TestContract");
+      } catch (err) {
+        errorThrown = true;
+        expect(err.message).to.contain("You must set `bytecodeHash: 'ipfs'`");
+      }
+      expect(errorThrown).to.equal(true, "Expected error for missing IPFS setting");
+    });
+  });*/
+});