feat: initial implementation

.eslintrc.js

@@ -0,0 +1,129 @@
+module.exports = {
+  parserOptions: {
+    ecmaVersion: 2018,
+    ecmaFeatures: {
+      impliedStrict: true,
+    },
+  },
+  extends: ['eslint:recommended', 'standard'],
+  env: {
+    es6: true,
+    mocha: true,
+    node: true,
+  },
+  // ADD ANY GLOBALS HERE!
+  globals: {
+    web3: false,
+    contract: false,
+    artifacts: false,
+  },
+  rules: {
+    'max-len': [
+      'error',
+      120,
+      2,
+      {
+        ignoreUrls: true,
+        ignoreComments: false,
+        ignoreRegExpLiterals: true,
+        ignoreStrings: false,
+        ignoreTemplateLiterals: false,
+      },
+    ],
+    quotes: [2, 'single', { avoidEscape: true }],
+    'prefer-promise-reject-errors': 1,
+    'standard/computed-property-even-spacing': 0,
+    'no-mixed-operators': 0,
+    'comma-dangle': 0,
+    camelcase: 0, // Due to info getter in eosjs
+    'no-unused-expressions': 1,
+    'no-template-curly-in-string': 2,
+    'no-extra-parens': [1, 'all'],
+    'no-misleading-character-class': 1,
+    'no-prototype-builtins': 1,
+    'no-async-promise-executor': 1,
+    'no-await-in-loop': 0, // should probably be on for perf dependent application
+    'require-atomic-updates': 1,
+    // best practices
+    'accessor-pairs': 1,
+    'array-callback-return': 0, // this best practice calls out the use of map over forEach
+    'class-methods-use-this': 1,
+    curly: [1, 'multi-or-nest', 'consistent'],
+    'dot-location': [2, 'property'],
+    'no-empty-function': 1,
+    'no-eval': 2,
+    'no-extend-native': 1,
+    'no-extra-bind': 1,
+    'no-implicit-coercion': 1,
+    'no-implicit-globals': 2,
+    'no-implied-eval': 2,
+    'no-lone-blocks': 1,
+    'no-loop-func': 1,
+    'no-magic-numbers': 0, // could be useful?
+    'no-new': 1,
+    'no-new-func': 2,
+    'no-new-wrappers': 1,
+    'no-param-reassign': 2,
+    'no-redeclare': [2, { builtinGlobals: true }],
+    'no-shadow': [
+      2,
+      {
+        builtinGlobals: true,
+        allow: [
+          'done',
+          'resolve',
+          'reject',
+          'cb', // x could potentially be added
+        ],
+      },
+    ],
+    'no-return-await': 1,
+    'no-script-url': 1,
+    'no-self-compare': 1,
+    'no-sequences': 1,
+    'no-throw-literal': 2,
+    'no-unmodified-loop-condition': 1,
+    'no-useless-call': 1,
+    'no-useless-catch': 1,
+    'no-useless-concat': 2,
+    'no-useless-escape': 2,
+    'no-useless-return': 0,
+    'no-console': [
+      'error',
+      {
+        allow: ['warn', 'error', 'info'],
+      },
+    ],
+    'no-warning-comments': [
+      1,
+      {
+        terms: ['fixme', 'todo'],
+        location: 'anywhere', // useful to highlight comments that need addressing
+      },
+    ],
+    'require-await': 1,
+    'vars-on-top': 2,
+    'wrap-iife': [2, 'inside'],
+    // strict mode
+    strict: [2, 'safe'],
+    // variables
+    'no-use-before-define': [
+      2,
+      {
+        variables: true,
+        functions: true,
+        classes: true,
+      },
+    ],
+    // node
+    'handle-callback-err': 1,
+    'no-buffer-constructor': 2,
+    'no-mixed-requires': 2,
+    'no-new-require': 0,
+    'no-path-concat': 1,
+    'no-sync': 1,
+    // stylistic (leaving up to standard)
+
+    // ECMAScript 6 (tbd)
+  },
+}

.gitignore

@@ -0,0 +1,11 @@
+node_modules
+.DS_Store
+.openzeppelin
+.env
+*.sw*
+
+#Hardhat files
+cache
+artifacts
+
+hidden_addresses*.csv

.nvmrc

@@ -0,0 +1 @@
+v16

.prettierignore

@@ -0,0 +1,2 @@
+artifacts
+cache

.prettierrc

@@ -0,0 +1,20 @@
+{
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true,
+  "bracketSpacing": true,
+  "printWidth": 120,
+  "overrides": [
+    {
+      "files": "*.sol",
+      "options": {
+        "printWidth": 150,
+        "tabWidth": 4,
+        "useTabs": false,
+        "singleQuote": false,
+        "bracketSpacing": false,
+        "explicitTypes": "always"
+      }
+    }
+  ]
+}

.solhint.json

@@ -0,0 +1,14 @@
+{
+  "rules": {
+    "no-unused-vars": "error",
+    "const-name-snakecase": "error",
+    "contract-name-camelcase": "error",
+    "event-name-camelcase": "error",
+    "func-name-mixedcase": "error",
+    "func-param-name-mixedcase": "error",
+    "modifier-name-mixedcase": "error",
+    "private-vars-leading-underscore": "error",
+    "var-name-mixedcase": "error",
+    "imports-on-top": "error"
+  }
+}

.soliumignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -1 +1,50 @@
-# pgala-compensation-plan-contracts
+# pgala-recovery-plan-contracts
+
+pGALA recovery plan contracts
+
+ 
+
+***
+
+ 
+
+## :guardsman: Smart Contract Tests
+
+```
+❍ npm install
+```
+
+```
+❍ npm run test
+```
+
+
+ 
+
+***
+
+ 
+
+## :white_check_mark: How to publish & verify
+
+Create an __.env__ file with the following fields:
+
+```
+BSC_MAINNET_NODE=
+BSCSCAN_API_KEY=
+BSC_MAINNET_PRIVATE_KEY=
+```
+
+
+### publish
+
+
+```
+❍ npx hardhat run --network mainnet scripts/deploy-script.js
+```
+
+### verify
+
+```
+❍ npx hardhat verify --network mainnet DEPLOYED_CONTRACT_ADDRESS "Constructor argument 1"
+```

contracts/Agreement.sol

@@ -0,0 +1,115 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {IERC777RecipientUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC777/IERC777RecipientUpgradeable.sol";
+import {IERC1820Registry} from "@openzeppelin/contracts/interfaces/IERC1820Registry.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Errors} from "./libraries/Errors.sol";
+
+contract Agreement is Initializable, OwnableUpgradeable, IERC777RecipientUpgradeable {
+    mapping(address => uint256) _toClaim;
+    mapping(address => uint256) _claimed;
+
+    string public ipfsMultihash;
+    address public token;
+
+    event AcceptedAndClaimed(address indexed owner, string ipfsMultihash, uint256 amount);
+    event IpfsMultihashChanged(string ipfsMultihash);
+    event ClaimForSet(address owner, uint256 amount);
+
+    function initialize(string calldata _ipfsMultihash, address _token) external initializer {
+        IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24).setInterfaceImplementer(
+            address(this),
+            keccak256("ERC777TokensRecipient"),
+            address(this)
+        );
+        ipfsMultihash = _ipfsMultihash;
+        token = _token;
+        __Ownable_init();
+    }
+
+    function tokensReceived(
+        address /*_operator*/,
+        address _from,
+        address /*_to*/,
+        uint256 /*_amount,*/,
+        bytes calldata /* _userData, */,
+        bytes calldata /*_operatorData */
+    ) external view override {
+        if (_msgSender() == token && _from != owner()) {
+            revert Errors.OnlyOwnerCanDepositToken();
+        }
+    }
+
+    function changeIpfsMultihash(string calldata _ipfsMultihash) external onlyOwner {
+        ipfsMultihash = _ipfsMultihash;
+        emit IpfsMultihashChanged(_ipfsMultihash);
+    }
+
+    function acceptAndClaim(string calldata _ipfsMultihash) external {
+        if (keccak256(abi.encodePacked((_ipfsMultihash))) != keccak256(abi.encodePacked((ipfsMultihash)))) {
+            revert Errors.InvalidIpfsMultiHash();
+        }
+
+        address msgSender = _msgSender();
+        uint256 amountToClaim = getClaimableAmountFor(msgSender);
+
+        if (amountToClaim == 0) {
+            revert Errors.NothingToClaim();
+        }
+
+        _acceptAndClaimFor(msgSender, msgSender, amountToClaim, _ipfsMultihash);
+    }
+
+    function acceptAndClaimManyOwner(address[] calldata _owners) external onlyOwner {
+        address msgSender = _msgSender();
+        for (uint256 i = 0; i < _owners.length; i++) {
+            uint256 amountToClaim = getClaimableAmountFor(_owners[i]);
+            _acceptAndClaimFor(_owners[i], msgSender, amountToClaim, "");
+        }
+    }
+
+    function acceptAndClaimOwner(address _owner) external onlyOwner {
+        uint256 amountToClaim = getClaimableAmountFor(_owner);
+        _acceptAndClaimFor(_owner, _msgSender(), amountToClaim, "");
+    }
+
+    function setClaimForMany(address[] calldata _owners, uint256[] calldata _amounts) public onlyOwner {
+        if (_owners.length != _amounts.length) {
+            revert Errors.InvalidLength();
+        }
+
+        for (uint256 i = 0; i < _owners.length; i++) {
+            setClaimFor(_owners[i], _amounts[i]);
+        }
+    }
+
+    function setClaimFor(address _owner, uint256 _amount) public onlyOwner {
+        if (_amount == 0) {
+            revert Errors.InvalidAmount();
+        }
+
+        _toClaim[_owner] = _amount;
+        emit ClaimForSet(_owner, _amount);
+    }
+
+    function getClaimableAmountFor(address _owner) public view returns (uint256) {
+        return _toClaim[_owner] - _claimed[_owner];
+    }
+
+    function getClaimedAmountFor(address _owner) public view returns (uint256) {
+        return _claimed[_owner];
+    }
+
+    function emergencyWithdraw() external onlyOwner {
+        IERC20(token).transfer(_msgSender(), IERC20(token).balanceOf(address(this)));
+    }
+
+    function _acceptAndClaimFor(address _owner, address _receiver, uint256 _amount, string memory _ipfsMultihash) internal {
+        _claimed[_owner] += _amount;
+        IERC20(token).transfer(_receiver, _amount);
+        emit AcceptedAndClaimed(_owner, _ipfsMultihash, _amount);
+    }
+}