adding ts versions

Author: karmabadger

package.json

@@ -3,5 +3,11 @@
   "dependencies": {
     "@nomiclabs/hardhat-ethers": "^2.0.6",
     "ethers": "^5.6.9"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.4",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.0.0",
+    "typescript": "^4.7.4"
   }
 }

scripts/deploy.ts

@@ -0,0 +1,77 @@
+// const { getSelectors, FacetCutAction } = require("./libraries/diamond.js");
+import { getSelectors, FacetCutAction } from "./libraries/diamond";
+const { ethers } = require("hardhat");
+
+async function deployDiamond() {
+  const accounts = await ethers.getSigners();
+  const contractOwner = accounts[0];
+
+  // deploy DiamondCutFacet
+  const DiamondCutFacet = await ethers.getContractFactory("DiamondCutFacet");
+  const diamondCutFacet = await DiamondCutFacet.deploy();
+  await diamondCutFacet.deployed();
+  console.log("DiamondCutFacet deployed:", diamondCutFacet.address);
+
+  // deploy Diamond
+  const Diamond = await ethers.getContractFactory("Diamond");
+  const diamond = await Diamond.deploy(
+    contractOwner.address,
+    diamondCutFacet.address
+  );
+  await diamond.deployed();
+  console.log("Diamond deployed:", diamond.address);
+
+  // deploy DiamondInit
+  // DiamondInit provides a function that is called when the diamond is upgraded to initialize state variables
+  // Read about how the diamondCut function works here: https://eips.ethereum.org/EIPS/eip-2535#addingreplacingremoving-functions
+  const DiamondInit = await ethers.getContractFactory("DiamondInit");
+  const diamondInit = await DiamondInit.deploy();
+  await diamondInit.deployed();
+  console.log("DiamondInit deployed:", diamondInit.address);
+
+  // deploy facets
+  console.log("");
+  console.log("Deploying facets");
+  const FacetNames = ["DiamondLoupeFacet", "OwnershipFacet"];
+  const cut = [];
+  for (const FacetName of FacetNames) {
+    const Facet = await ethers.getContractFactory(FacetName);
+    const facet = await Facet.deploy();
+    await facet.deployed();
+    console.log(`${FacetName} deployed: ${facet.address}`);
+    cut.push({
+      facetAddress: facet.address,
+      action: FacetCutAction.Add,
+      functionSelectors: getSelectors(facet),
+    });
+  }
+
+  // upgrade diamond with facets
+  console.log("Diamond Cut:", cut);
+  const diamondCut = await ethers.getContractAt("IDiamondCut", diamond.address);
+  let tx;
+  let receipt;
+  // call to init function
+  let functionCall = diamondInit.interface.encodeFunctionData("init");
+  tx = await diamondCut.diamondCut(cut, diamondInit.address, functionCall);
+  console.log("Diamond cut tx: ", tx.hash);
+  receipt = await tx.wait();
+  if (!receipt.status) {
+    throw Error(`Diamond upgrade failed: ${tx.hash}`);
+  }
+  console.log("Completed diamond cut");
+  return diamond.address;
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+if (require.main === module) {
+  deployDiamond()
+    .then(() => process.exit(0))
+    .catch((error) => {
+      console.error(error);
+      process.exit(1);
+    });
+}
+
+exports.deployDiamond = deployDiamond;

scripts/genSelectors.ts

@@ -0,0 +1,48 @@
+import { ContractFactory, utils } from "ethers";
+import path from "path/posix";
+
+const args = process.argv.slice(2);
+
+if (args.length != 1) {
+  console.log(`please supply the correct parameters:
+    facetName
+  `);
+  process.exit(1);
+}
+
+async function printSelectors(
+  contractName: string,
+  artifactFolderPath: string = "../out"
+) {
+  const contractFilePath = path.join(
+    artifactFolderPath,
+    `${contractName}.sol`,
+    `${contractName}.json`
+  );
+  const contractArtifact = require(contractFilePath);
+  const abi = contractArtifact.abi;
+  const bytecode = contractArtifact.bytecode;
+  const target = new ContractFactory(abi, bytecode);
+  const signatures = Object.keys(target.interface.functions);
+
+  const selectors = signatures.reduce((acc: string[], val) => {
+    if (val !== "init(bytes)") {
+      acc.push(target.interface.getSighash(val));
+    }
+    return acc;
+  }, []);
+
+  const coder = utils.defaultAbiCoder;
+  const coded = coder.encode(["bytes4[]"], [selectors]);
+
+  process.stdout.write(coded);
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+printSelectors(args[0], args[1])
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

scripts/libraries/diamond.ts

@@ -0,0 +1,86 @@
+import * as ethers from "ethers";
+
+const FacetCutAction = { Add: 0, Replace: 1, Remove: 2 };
+
+// get function selectors from ABI
+function getSelectors(contract: ethers.Contract) {
+  const signatures = Object.keys(contract.interface.functions);
+  const selectors = signatures.reduce((acc: string[], val) => {
+    if (val !== "init(bytes)") {
+      acc.push(contract.interface.getSighash(val));
+    }
+    return acc;
+  }, []);
+  // selectors.contract = contract
+  // selectors.remove = remove
+  // selectors.get = get
+  return selectors;
+}
+
+// get function selector from function signature
+function getSelector(func: any) {
+  const abiInterface = new ethers.utils.Interface([func]);
+  return abiInterface.getSighash(ethers.utils.Fragment.from(func));
+}
+
+// used with getSelectors to remove selectors from an array of selectors
+// functionNames argument is an array of function signatures
+function remove(this: any, functionNames: string[]) {
+  const selectors = this.filter((v: any) => {
+    for (const functionName of functionNames) {
+      if (v === this.contract.interface.getSighash(functionName)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  // selectors.contract = this.contract
+  // selectors.remove = this.remove
+  // selectors.get = this.get
+  return selectors;
+}
+
+// used with getSelectors to get selectors from an array of selectors
+// functionNames argument is an array of function signatures
+function get(this: any, functionNames: string[]) {
+  const selectors = this.filter((v: any) => {
+    for (const functionName of functionNames) {
+      if (v === this.contract.interface.getSighash(functionName)) {
+        return true;
+      }
+    }
+    return false;
+  });
+  // selectors.contract = this.contract
+  // selectors.remove = this.remove
+  // selectors.get = this.get
+  return selectors;
+}
+
+// remove selectors using an array of signatures
+function removeSelectors(selectors: any[], signatures: any[]) {
+  const iface = new ethers.utils.Interface(
+    signatures.map((v: any) => "function " + v)
+  );
+  const removeSelectors = signatures.map((v) => iface.getSighash(v));
+  selectors = selectors.filter((v) => !removeSelectors.includes(v));
+  return selectors;
+}
+
+// find a particular address position in the return value of diamondLoupeFacet.facets()
+function findAddressPositionInFacets(facetAddress: any, facets: any) {
+  for (let i = 0; i < facets.length; i++) {
+    if (facets[i].facetAddress === facetAddress) {
+      return i;
+    }
+  }
+}
+
+export {
+  getSelectors,
+  getSelector,
+  FacetCutAction,
+  remove,
+  removeSelectors,
+  findAddressPositionInFacets,
+};

tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "declaration": true,
+    "rootDir": "./",
+    "baseUrl": "./",
+    "paths": {
+      "@src/*": ["src/*"],
+      "@utils/*": ["./utils/*"],
+      "@scripts/*": ["./scripts/*"],
+      "@tests/*": ["tests/*"],
+      "@customTypes/*": ["./types/*"],
+      "@utils/": ["./utils/*"],
+      "@migrations/*": ["./migrations/*"],
+      "@typechain-types/*": ["./typechain-types/*"]
+    }
+  },
+  "include": ["./scripts", "./test", "./typechain"]
+}