@velocitycareerlabs/verification-coupon-contract 1.25.0-dev-build.12642c864

package/contracts/Migrations.sol

@@ -0,0 +1,18 @@
+pragma solidity 0.8.4;
+
+contract Migrations {
+  address public owner = msg.sender;
+  uint public last_completed_migration;
+
+  modifier restricted() {
+    require(
+      msg.sender == owner,
+      "This function is restricted to the contract's owner"
+    );
+    _;
+  }
+
+  function setCompleted(uint completed) public restricted {
+    last_completed_migration = completed;
+  }
+}

package/contracts/VerificationCoupon.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.4;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
+import "@velocitycareerlabs/permissions-contract/contracts/Permissions.sol";
+
+/**
+ * @dev {ERC721} token, including:
+ *
+ *  - ability for holders to burn (destroy) their tokens
+ *  - a minter role that allows for token minting (creation)
+ *  - a pauser role that allows to stop all token transfers
+ *  - token ID and URI autogeneration
+ *
+ * This contract uses {AccessControl} to lock permissioned functions using the
+ * different roles - head to its documentation for details.
+ *
+ * The account that deploys the contract will be granted the minter and pauser
+ * roles, as well as the default admin role, which will let it grant both minter
+ * and pauser roles to other accounts.
+ */
+contract VerificationCoupon is Initializable, AccessControlEnumerableUpgradeable, ERC1155Upgradeable {
+    address VNF;
+    using CountersUpgradeable for CountersUpgradeable.Counter;
+    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
+
+    mapping(uint256 => uint256) private expirationTime;
+
+    mapping(address => uint256[]) private ownerTokens;
+
+    CountersUpgradeable.Counter private _tokenIdTracker;
+
+    string private _tokenName;
+
+    Permissions internal permissions;
+
+    event MintCouponBundle(address owner, uint256 bundleId, uint256 expirationTime, uint256 quantity, string traceId, string ownerDid);
+
+    event BurnCoupon(address owner, uint256 bundleId, string traceId, string caoDid, string burnerDid, uint256 balance, uint256 expirationTime, uint256 burnTime);
+
+    function initialize(string memory tokenName, string memory baseTokenURI) public initializer {
+        ERC1155Upgradeable.__ERC1155_init(baseTokenURI);
+        VNF = msg.sender;
+        _tokenName = tokenName;
+
+        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        _setupRole(MINTER_ROLE, msg.sender);
+    }
+
+    function setPermissionsAddress(address _permissions) public {
+        require(msg.sender == VNF, "The caller is not VNF");
+        permissions = Permissions(_permissions);
+    }
+
+    function getVNF() public view returns (address) {
+        return VNF;
+    }
+
+    function isExpired(uint256 tokenId) public view returns (bool) {
+        return block.timestamp >= expirationTime[tokenId];
+    }
+
+    function getTokenId(address operator) public view returns (uint256) {
+        address primary = permissions.checkOperator(operator);
+        uint256 quantity = ownerTokens[primary].length;
+        require(quantity != 0, "No available tokens");
+
+        uint256 lowestTokenId = type(uint256).max;
+        uint256 currentTokenId;
+        for (uint256 i = 0; i < quantity; i++) {
+            currentTokenId = ownerTokens[primary][i];
+            if (!isExpired(currentTokenId) && currentTokenId < lowestTokenId) {
+                lowestTokenId = currentTokenId;
+            }
+        }
+        require(lowestTokenId != type(uint256).max, "No available tokens");
+        return lowestTokenId;
+    }
+
+    function removeTokenId(uint256 tokenId, address burnAddress) private {
+        uint256[] storage tokenList = ownerTokens[burnAddress];
+        for (uint256 i = 0; i < tokenList.length; i++) {
+            if (tokenId == tokenList[i]) {
+                tokenList[i] = tokenList[tokenList.length - 1];
+                return tokenList.pop();
+            }
+        }
+    }
+
+    function mint(address to, uint256 _expirationTime, uint256 quantity, string memory traceId, string memory ownerDid) public virtual {
+        require(hasRole(MINTER_ROLE, msg.sender), "VerificationCoupon: must have a minter role to mint");
+        require(quantity > 0, "Invalid quantity");
+
+        uint256 tokenId = _tokenIdTracker.current();
+        _mint(to, tokenId, quantity, "");
+        ownerTokens[to].push(tokenId);
+        expirationTime[tokenId] = _expirationTime;
+        _tokenIdTracker.increment();
+        emit MintCouponBundle(to, tokenId, _expirationTime, quantity, traceId, ownerDid);
+    }
+
+    function burn(uint256 tokenId, string memory traceId, string memory caoDid, string memory burnerDid, address operator) public virtual {
+        require(permissions.checkAddressScope(msg.sender, "coupon:burn"), "Burn: caller does not have coupon:burn permission");
+        address primary = permissions.checkOperator(operator);
+        require(balanceOf(primary, tokenId) > 0, "Burn: bundle has no balance");
+        burnExpiredTokens(primary);
+
+        _burn(primary, tokenId, 1);
+        uint256 balance = balanceOf(primary, tokenId);
+        uint256 expiration = expirationTime[tokenId];
+        if (balance == 0) {
+            delete expirationTime[tokenId];
+            removeTokenId(tokenId, primary);
+        }
+        emit BurnCoupon(primary, tokenId, traceId, caoDid, burnerDid, balance, expiration, block.timestamp);
+    }
+
+    function burnExpiredTokens(address burnAddress) private {
+        uint256 quantity = ownerTokens[burnAddress].length;
+        uint256 currentTokenId;
+        uint256 i = 0;
+        while (i < quantity) {
+            currentTokenId = ownerTokens[burnAddress][i];
+            if (isExpired(currentTokenId)) {
+                uint256 balance = balanceOf(burnAddress, currentTokenId);
+                _burn(burnAddress, currentTokenId, balance);
+                delete expirationTime[currentTokenId];
+                removeTokenId(currentTokenId, burnAddress);
+                quantity--;
+            } else {
+                i++;
+            }
+        }
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerableUpgradeable, ERC1155Upgradeable) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    function _getTokenName() public view virtual returns (string memory) {
+        return _tokenName;
+    }
+}

package/migration-status.js

@@ -0,0 +1,41 @@
+const Web3 = require('web3');
+const Migrations = require('./build/contracts/Migrations.json');
+const truffleConfig = require('./truffle-config');
+
+const cmd = process.argv[2] || 'get';
+const env = process.argv[3] || 'localdocker';
+const value = process.argv[4] || '1';
+const networkId = truffleConfig.networks[env].network_id;
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+const config = {
+  contractAddress: Migrations.networks[networkId].address,
+  provider: truffleConfig.networks[env].provider,
+  gas: truffleConfig.networks[env].gas,
+  gasPrice: truffleConfig.networks[env].gasPrice,
+};
+
+const main = async () => {
+  const web3 = new Web3(config.provider);
+
+  const instance = new web3.eth.Contract(
+    Migrations.abi,
+    config.contractAddress
+  );
+
+  if (cmd === 'set') {
+    await instance.methods.setCompleted(value).send({
+      from: config.provider.addresses[0],
+      gas: config.gas,
+      gasPrice: config.gasPrice,
+    });
+  }
+
+  const lastCompletedMigration = await instance.methods
+    .last_completed_migration()
+    .call();
+  console.log('last_completed_migration:', lastCompletedMigration);
+};
+
+main();

package/migrations/10_vl-3756-emit-burn-time.js

@@ -0,0 +1,17 @@
+const truffleConfig = require('../truffle-config.js');
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2])
+console.log('ENV:', env)
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`).proxies[1].address
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async function (deployer) {
+    const instance = await upgradeProxy(contractAddress, VerificationCoupon, { deployer });
+    console.log('Upgraded', instance.address);
+};

package/migrations/11_vl-5092-new-permissions.js

@@ -0,0 +1,21 @@
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const truffleConfig = require('../truffle-config');
+
+const VerificationCoupon = artifacts.require('VerificationCoupon');
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2]);
+console.log('ENV:', env);
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`)
+  .proxies[1].address;
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async (deployer) => {
+  const instance = await upgradeProxy(contractAddress, VerificationCoupon, {
+    deployer,
+  });
+  console.log('Upgraded', instance.address);
+};

package/migrations/12_vl-8185-allow-unknown-types.js

@@ -0,0 +1,21 @@
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const truffleConfig = require('../truffle-config');
+
+const VerificationCoupon = artifacts.require('VerificationCoupon');
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2]);
+console.log('ENV:', env);
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`)
+  .proxies[1].address;
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async (deployer) => {
+  const instance = await upgradeProxy(contractAddress, VerificationCoupon, {
+    deployer,
+  });
+  console.log('Upgraded', instance.address);
+};

package/migrations/1_initial_migration.js

@@ -0,0 +1,5 @@
+const Migrations = artifacts.require("Migrations");
+
+module.exports = function (deployer) {
+  deployer.deploy(Migrations);
+};

package/migrations/2_deploy_contract.js

@@ -0,0 +1,9 @@
+const { deployProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+module.exports = async function (deployer) {
+    const name = "Velocity Verification Coupon";
+    const baseTokenURI = "https://www.velocitynetwork.foundation/";
+    const instance = await deployProxy(VerificationCoupon, [name, baseTokenURI], { deployer });
+    console.log('Deployed', instance.address);
+};

package/migrations/3_deploy_contract_ERC_1155.js

@@ -0,0 +1,9 @@
+const { deployProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+module.exports = async function (deployer) {
+    const name = "Velocity Verification Coupon";
+    const baseTokenURI = "https://www.velocitynetwork.foundation/";
+    const instance = await deployProxy(VerificationCoupon, [name, baseTokenURI], { deployer });
+    console.log('Deployed', instance.address);
+};

package/migrations/4_set_balances.js

@@ -0,0 +1,65 @@
+const Web3 = require('web3');
+const fs = require('fs');
+const VerificationCouponV2 = require("../build/contracts/VerificationCoupon");
+const VerificationCouponV1 = require('./contracts-v1/verification-coupon.json');
+const truffleConfig = require('../truffle-config.js');
+
+const env = process.argv[4] || 'localdocker';
+console.log('ENV:', env)
+const networkId = truffleConfig.networks[env].network_id;
+
+const proxies = require(`../.openzeppelin/unknown-${networkId}.json`).proxies;
+const config = {
+  contractAddressV1: proxies[0].address,
+  contractAddressV2: proxies[1].address,
+  provider: truffleConfig.networks[env].provider,
+  gas: truffleConfig.networks[env].gas,
+  gasPrice: truffleConfig.networks[env].gasPrice,
+};
+console.log(`ENV: ${env} Network Id: ${networkId}`, config);
+
+
+
+module.exports = async function (deployer) {
+    // const web3 = new Web3(config.provider);
+    // const instanceV1 = new web3.eth.Contract(VerificationCouponV1.abi, config.contractAddressV1);
+    //
+    // const events = await instanceV1.getPastEvents('MintCouponBundle', {
+    //     fromBlock: 0,
+    //     toBlock: 'latest'
+    // });
+    // fs.writeFileSync(`_${env}-events-mint.json`, JSON.stringify(events))
+    // const balances = events.reduce((acc, { returnValues: { owner, ownerDid } })=> {
+    //   acc[owner] = { value:0,  ownerDid } ;
+    //   return acc;
+    // }, {});
+    // for(let account in balances) {
+    //   balances[account].value = await instanceV1.methods.balanceOf(account).call();
+    // }
+    // console.log('Balances:', balances);
+    // fs.writeFileSync(`_${env}-balances.json`, JSON.stringify(balances))
+    //
+    // const expirationTime = Math.floor(Date.now() / 1000) + 3 * 30 * 24 * 60 * 60;
+    // const traceId = 'migration';
+    // const instanceV2 = new web3.eth.Contract(VerificationCouponV2.abi, config.contractAddressV2);
+    // const migratedBalances = {};
+    // for(let account in balances) {
+    //   console.log('Minting:', account, balances[account]);
+    //   if (Number(balances[account].value) > 0) {
+    //     await instanceV2.methods.mint(account, expirationTime, balances[account].value, traceId, balances[account].ownerDid).send({
+    //       from: config.provider.addresses[0],
+    //       gas: config.gas,
+    //       gasPrice: config.gasPrice
+    //     });
+    //   }
+    //   migratedBalances[account] = balances[account];
+    //   console.log('Minted:', account, balances[account]);
+    // }
+    // fs.writeFileSync(`_${env}-migrated-balances-v2.json`, JSON.stringify(migratedBalances));
+    // const eventsV2 = await instanceV2.getPastEvents('MintCouponBundle', {
+    //   fromBlock: 0,
+    //   toBlock: 'latest'
+    // });
+    // fs.writeFileSync(`_${env}-events-mint-v2.json`, JSON.stringify(eventsV2));
+    console.log('Balances migrated!');
+};

package/migrations/5_remove_tx_origin.js

@@ -0,0 +1,19 @@
+const truffleConfig = require('../truffle-config.js');
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2])
+console.log('ENV:', env)
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`).proxies[1].address
+const permissionsContractAddress = require(`../../permissions/.openzeppelin/unknown-${networkId}.json`).proxies[0].address
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async function (deployer) {
+    const instance = await upgradeProxy(contractAddress, VerificationCoupon, { deployer });
+    console.log('Upgraded', instance.address);
+    await instance.setPermissionsAddress(permissionsContractAddress)
+};

package/migrations/6_vl-2898-operator_burn.js

@@ -0,0 +1,17 @@
+const truffleConfig = require('../truffle-config.js');
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2])
+console.log('ENV:', env)
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`).proxies[1].address
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async function (deployer) {
+    const instance = await upgradeProxy(contractAddress, VerificationCoupon, { deployer });
+    console.log('Upgraded', instance.address);
+};

package/migrations/7_vl-2898-fix-get-token-id-operator.js

@@ -0,0 +1,17 @@
+const truffleConfig = require('../truffle-config.js');
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2])
+console.log('ENV:', env)
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`).proxies[1].address
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async function (deployer) {
+    const instance = await upgradeProxy(contractAddress, VerificationCoupon, { deployer });
+    console.log('Upgraded', instance.address);
+};

package/migrations/8_vl-4587-get-token-id-expired-behavior.js

@@ -0,0 +1,17 @@
+const truffleConfig = require('../truffle-config.js');
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2])
+console.log('ENV:', env)
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`).proxies[1].address
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async function (deployer) {
+    const instance = await upgradeProxy(contractAddress, VerificationCoupon, { deployer });
+    console.log('Upgraded', instance.address);
+};

package/migrations/9_vl-3994-emit-balance-expiration.js

@@ -0,0 +1,17 @@
+const truffleConfig = require('../truffle-config.js');
+const { upgradeProxy } = require('@openzeppelin/truffle-upgrades');
+const VerificationCoupon = artifacts.require("VerificationCoupon");
+
+const env = process.argv[4] || 'localdocker';
+console.log(process.argv[2])
+console.log('ENV:', env)
+const networkId = truffleConfig.networks[env].network_id;
+
+const contractAddress = require(`../.openzeppelin/unknown-${networkId}.json`).proxies[1].address
+
+console.log(`ENV: ${env} Network Id: ${networkId}`);
+
+module.exports = async function (deployer) {
+    const instance = await upgradeProxy(contractAddress, VerificationCoupon, { deployer });
+    console.log('Upgraded', instance.address);
+};