New contracts and tests

.vscode/settings.json

@@ -0,0 +1,15 @@
+{
+  "editor.defaultFormatter": "rvest.vs-code-prettier-eslint",
+  "editor.formatOnPaste": false, // required
+  "editor.formatOnType": false, // required
+  "editor.formatOnSave": true, // optional
+  "editor.formatOnSaveMode": "file", // required to format on save
+  "files.autoSave": "onFocusChange", // optional but recommended
+  "vs-code-prettier-eslint.prettierLast": "false",
+  "[solidity]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "vscode.typescript-language-features"
+  } // set as "true" to run 'prettier' last not first
+}

address.txt

@@ -0,0 +1,2 @@
+Deployed Sadaiv Id contract to: 0x600Ab5D16c937039CFA4818945BD37974449E3c5
+Deployed Sadaiv Backup contract to: 0xBFdD75A2098A177AD44A15480Ec20d650d981884

contracts/SadaivBackup.sol

@@ -0,0 +1,66 @@
+//SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+contract SadaivBackup {
+  mapping(address => bool) public owners;
+
+  constructor() {
+    owners[msg.sender] = true;
+  }
+
+  modifier onlyOwner() {
+    require(owners[msg.sender], "Not authorized!");
+    _;
+  }
+
+  function makeOwner(address _address) public onlyOwner {
+    owners[_address] = true;
+  }
+
+  function checkIfOwner(address _address) public view returns (bool) {
+    return owners[_address];
+  }
+
+  struct Build {
+    string branch;
+    string commitMessage;
+    string commitHash;
+    string timestamp;
+    uint256 contributorGithubId;
+    string backupCid;
+    string changesCid; //future scope
+  }
+
+  struct Repository {
+    uint256 id;
+    string name;
+    string fullname;
+    string description;
+    uint256 ownerGithubId;
+    uint256 size;
+    uint256 parentRepo;
+    string defaultBranch;
+    string timestamp;
+    string[] topics;
+    string[] languages;
+  }
+
+  mapping(uint256 => Repository) public userRepos; //repoId => repo
+  mapping(uint256 => mapping(bytes32 => Build)) public repoBuilds; //repoId => hash(barnch+commitHash) => build
+
+  event NewBuild(Repository repository, Build build, bytes32 buildhash);
+
+  function createNewBuild(
+    Repository memory _repo,
+    Build memory _build
+  ) public onlyOwner {
+    userRepos[_repo.id] = _repo;
+    bytes32 buildhash = keccak256(
+      abi.encodePacked(
+        string(abi.encodePacked(_build.branch, _build.commitHash))
+      )
+    );
+    repoBuilds[_repo.id][buildhash] = _build;
+    emit NewBuild(_repo, _build, buildhash);
+  }
+}

contracts/SadaivId.sol

@@ -0,0 +1,74 @@
+//SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/utils/Counters.sol";
+
+contract SadaivId {
+  mapping(address => bool) public owners;
+  using Counters for Counters.Counter;
+  Counters.Counter public sadaivId;
+
+  constructor() {
+    owners[msg.sender] = true;
+  }
+
+  modifier onlyOwner() {
+    require(owners[msg.sender], "Not authorized!");
+    _;
+  }
+
+  function makeOwner(address _address) public onlyOwner {
+    owners[_address] = true;
+  }
+
+  function checkIfOwner(address _address) public view returns (bool) {
+    return owners[_address];
+  }
+
+  mapping(uint256 => mapping(uint256 => bool)) public sadaivIdToGithubId;
+  mapping(address => uint256) public SCWAddressToSadaivId;
+  mapping(uint256 => string) public contributorData; //sadaiv id to contributor data cid
+
+  event NewUser(uint256 sadaivId, address scwAddress);
+  event NewProfileChange(uint256 sadaivId, string cid);
+  event NewProvider(uint256 sadaivId, uint256 provider);
+
+  //register new user(with scw address) if not already registered
+  function registerUser() public returns (uint256) {
+    require(SCWAddressToSadaivId[msg.sender] == 0, "Address already registered.");
+    sadaivId.increment();
+    uint256 currentId = sadaivId.current();
+
+    SCWAddressToSadaivId[msg.sender] = currentId;
+    emit NewUser(currentId, msg.sender);
+    return currentId;
+  }
+
+  function userExists(address scwAddress) public view returns (bool) {
+    return SCWAddressToSadaivId[scwAddress] != 0;
+  }
+
+  //function to add github account ids for a sadaiv userid
+  function addProviders(
+    address scw,
+    uint256 _newId
+  ) public onlyOwner {
+    require(SCWAddressToSadaivId[scw] != 0, "Address not registered.");
+    uint256 _sadaivId = SCWAddressToSadaivId[scw];
+    require(
+      !sadaivIdToGithubId[_sadaivId][_newId],
+      "Provider already registered."
+    );
+    sadaivIdToGithubId[_sadaivId][_newId] = true;
+    emit NewProvider(_sadaivId, _newId);
+  }
+
+  //change the contributor data cid
+  function changeContributorData(
+    string memory cid
+  ) public {
+    require(SCWAddressToSadaivId[msg.sender] != 0, "Address not registered.");
+    uint256 _sadaivId = SCWAddressToSadaivId[msg.sender];
+    contributorData[_sadaivId] = cid;
+    emit NewProfileChange(_sadaivId, cid);
+  }
+}

package.json

@@ -10,10 +10,10 @@
     "@types/mocha": "^9.1.1",
     "@types/node": "^12.20.55",
     "@typescript-eslint/eslint-plugin": "^4.33.0",
-    "@typescript-eslint/parser": "^4.33.0",
+    "@typescript-eslint/parser": "^5.0.1",
     "chai": "^4.3.7",
     "dotenv": "^10.0.0",
-    "eslint": "^7.32.0",
+    "eslint": "^8.7.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-config-standard": "^16.0.3",
     "eslint-plugin-import": "^2.26.0",
@@ -24,12 +24,16 @@
     "ethers": "^5.7.2",
     "hardhat": "^2.12.3",
     "hardhat-gas-reporter": "^1.0.9",
-    "prettier": "^2.8.0",
+    "prettier": "^2.5.1",
     "prettier-plugin-solidity": "^1.0.0",
     "solhint": "^3.3.7",
     "solidity-coverage": "^0.7.22",
     "ts-node": "^10.9.1",
     "typechain": "^5.2.0",
-    "typescript": "^4.9.3"
+    "typescript": "^4.4.4"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^4.8.3",
+    "ethereumjs-util": "^7.1.5"
   }
 }

scripts/backup.ts

@@ -0,0 +1,40 @@
+const hre = require("hardhat");
+
+async function main() {
+  const address = "0xed2947e0c9851EF1c5B25d80d953e458aaeA4f5A";
+  const backupContractFactory = await hre.ethers.getContractFactory("SadaivBackup");
+  const backupContract = await backupContractFactory.attach(address);
+
+  const repository = {
+    id:581591975,
+    name: 'ask-on-chain',
+    fullname: 'aditipolkam/ask-on-chain',
+    description: 'a platform to fearlessly ask questions to whomsoever you want by maintaining anonymity',
+    ownerGithubId: 60136767,
+    size: 254,
+    parentRepo:0,
+    defaultBranch: 'main',
+    timestamp: "1680783864",
+    topics: ["anonymity","blockchain","nextjs","question-answering","solidity"],
+    languages: ['Solidity', 'JavaScript', 'HTML', 'CSS'],
+  };
+
+  const build = {
+    branch: 'main',
+    commitMessage: 'docs:📝 update readme',
+    commitHash: "8661f4cf0daa26437f26adfdc1b6a330f8cddcb6",
+    timestamp:"1680783864",
+    contributorGithubId: 60136767,
+    backupCid: 'QmbHafwh5DargwKUgpraA2HtskAKbRRqyviVxBhsd8JJY9',
+    changesCid: '',
+  };
+
+  let txn = await backupContract.createNewBuild(repository, build);
+  await txn.wait();
+  console.log("Backed up");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/deploy.ts

@@ -1,16 +1,18 @@
-import { ethers } from "hardhat";
-
-async function main() {
-  // get contract and deploy to blockchain
-  const Sadaiv = await ethers.getContractFactory("Sadaiv");
-  const sadaiv = await Sadaiv.deploy();
-
-  await sadaiv.deployed();
-
-  console.log("Deployed Sadaiv contract to:", sadaiv.address);
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
+import { ethers } from "hardhat";
+
+async function main() {
+  const sadaivId = await ethers.getContractFactory("SadaivId");
+  const sadaivIdContract = await sadaivId.deploy();
+  await sadaivIdContract.deployed();
+  console.log("Deployed Sadaiv Id contract to:", sadaivIdContract.address);
+
+  const backup = await ethers.getContractFactory("SadaivBackup");
+  const backupContract = await backup.deploy();
+  await backupContract.deployed();
+  console.log("Deployed Sadaiv Backup contract to:", backupContract.address);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/registerUser.ts

@@ -0,0 +1,27 @@
+import { ethers } from "hardhat";
+
+const hre = require("hardhat");
+require('dotenv').config();
+
+async function main() {
+  const backupContractFactory = await hre.ethers.getContractFactory("SadaivId");
+  const backupContract = await backupContractFactory.attach("0xd4204fe1a1Fe7742DdD3A95494286aD558768aA5");
+
+  const verifyContractFactory = await await hre.ethers.getContractFactory("VerifySignature");
+  const verifyContract = await verifyContractFactory.attach("0xACf276963A21F63E07f28eA5b212a47014f4d95F");
+    console.log(process.env.PRIVATE_KEY as string)
+  const signer = await ethers.getSigner(process.env.PRIVATE_KEY as string)
+  const message = 'You agree that you the owner of this address are registering on SadaivId';
+
+  const hash = await verifyContract.getMessageHash(message)
+  const signature = await signer.signMessage(ethers.utils.arrayify(hash))
+
+  let txn = await backupContract.registerUser(message, signature, signer.getAddress());
+  await txn.wait();
+  console.log("Registered");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

test/addProvider.ts

@@ -0,0 +1,53 @@
+import { ethers } from 'hardhat';
+import { Signer } from 'ethers';
+import { expect } from 'chai';
+import { SadaivId } from '../typechain';
+require('dotenv').config();
+
+let sadaivIdContract: SadaivId;
+let signer: Signer;
+let user: Signer;
+
+before(async () => {
+
+  const SadaivId = await ethers.getContractFactory('SadaivId');
+  [signer, user] = await ethers.getSigners();
+
+  sadaivIdContract = await SadaivId.deploy();
+  await sadaivIdContract.deployed();
+});
+
+it('should register a new user', async () => {
+  const walletAddress = await signer.getAddress();
+
+  await expect(sadaivIdContract.registerUser())
+    .to.emit(sadaivIdContract, 'NewUser')
+    .withArgs(1, walletAddress);
+
+  const sadaivId = await sadaivIdContract.SCWAddressToSadaivId(walletAddress);
+
+  expect(sadaivId).to.equal(1);
+});
+
+
+it('should add a new provider', async () => {
+  const newId = 12345;
+  const sadaivId = 1;
+
+  await expect(sadaivIdContract.addProviders(newId))
+    .to.emit(sadaivIdContract, 'NewProvider')
+    .withArgs(sadaivId, newId);
+
+  expect(await sadaivIdContract.sadaivIdToGithubId(sadaivId, newId)).to.be.true;
+});
+
+it('should change contributor data', async () => {
+  const cid = 'awbfhpiegji4758347v8n12392nbijq2iou48vbu';
+  const sadaivId = 1;
+
+  await expect(sadaivIdContract.changeContributorData(cid))
+    .to.emit(sadaivIdContract, 'NewProfileChange')
+    .withArgs(sadaivId, cid);
+
+  expect(await sadaivIdContract.contributorData(sadaivId)).to.equal(cid);
+});

test/createBuild.ts

@@ -0,0 +1,45 @@
+import { ethers } from 'hardhat';
+import { expect } from 'chai';
+import { SadaivBackup } from '../typechain';
+require('dotenv').config();
+
+let sadaivBackupContract: SadaivBackup;
+
+beforeEach(async () => {
+  const SadaivBackup = await ethers.getContractFactory('SadaivBackup');
+  sadaivBackupContract = await SadaivBackup.deploy();
+  await sadaivBackupContract.deployed();
+});
+
+it('should create a new build', async () => {
+  const repository = {
+    id: 1,
+    parentRepo: 0,
+    timestamp: '322',
+    name: 'Repo1',
+    fullname: 'Fullname1',
+    description: 'Description1',
+    ownerGithubId: 12345,
+    size: 100,
+    defaultBranch: 'main',
+    topics: ['topic1', 'topic2'],
+    languages: ['Solidity'],
+  };
+
+  const build = {
+    timestamp: '3232',
+    branch: 'branch1',
+    commitHash: 'ksj32fs',
+    commitMessage: 'Commit Message1',
+    contributorGithubId: 67890,
+    backupCid: 'CID123',
+    changesCid: 'CID456',
+  };
+
+  const repoId = 1;
+
+  await expect(
+    sadaivBackupContract.createNewBuild(repository, build)
+  )
+    .to.emit(sadaivBackupContract, 'NewBuild');
+});

test/registerUser.ts

@@ -0,0 +1,31 @@
+import { ethers } from 'hardhat';
+import { Signer } from 'ethers';
+import { expect } from 'chai';
+import { SadaivId } from '../typechain';
+require('dotenv').config();
+
+let sadaivIdContract: SadaivId;
+let signer: Signer;
+let user: Signer;
+
+before(async () => {
+  const SadaivId = await ethers.getContractFactory('SadaivId');
+  [signer, user] = await ethers.getSigners();
+
+  sadaivIdContract = await SadaivId.deploy();
+  await sadaivIdContract.deployed();
+});
+
+it('should register a new user', async () => {
+  const githubId = 12345;
+  const walletAddress = await signer.getAddress();
+
+  await expect(sadaivIdContract.registerUser())
+    .to.emit(sadaivIdContract, 'NewUser')
+    .withArgs(1, walletAddress);
+
+  const sadaivId = await sadaivIdContract.SCWAddressToSadaivId(walletAddress);
+
+  expect(sadaivId).to.equal(1);
+  expect(await sadaivIdContract.sadaivIdToGithubId(sadaivId, githubId)).to.be.false;
+});