@coti-io/coti-contracts 0.1.0

package/contracts/mocks/wallet/PrivateERC20Wallet/PrivateERC20WalletMock.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/IPrivateERC20.sol";
+
+contract PrivateERC20WalletMock {
+    constructor() {}
+
+    function setAccountEncryptionAddress(address token, address accountEncryptionAddress) public returns (bool) {
+        return IPrivateERC20(token).setAccountEncryptionAddress(accountEncryptionAddress);
+    }
+
+    function transfer(address token, address to, uint64 value) public returns (gtBool) {
+        return IPrivateERC20(token).transfer(to, MpcCore.setPublic64(value));
+    }
+
+    function approve(address token, address spender, uint64 value) public returns (bool) {
+        return IPrivateERC20(token).approve(spender, MpcCore.setPublic64(value));
+    }
+
+    function transferFrom(address token, address from, address to, uint64 value) public returns (gtBool) {
+        return IPrivateERC20(token).transferFrom(from, to, MpcCore.setPublic64(value));
+    }
+}

package/contracts/onboard/AccountOnboard.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../utils/mpc/MpcCore.sol";
+
+contract AccountOnboard {
+
+    event AccountOnboarded(address indexed _from, bytes userKey);
+
+    /**
+     * @notice onboards the account and emits the users AES encryption key in encrypted form
+     * @dev the AES key must be decrypted in order to be used to pass encrypted data to the chain
+     * @param publicKey RSA public key
+     * @param signedEK signed hash of the RSA public key
+     */
+    function onboardAccount(bytes calldata publicKey, bytes calldata signedEK) public {
+        bytes memory accountKey = MpcCore.getUserKey(publicKey, signedEK);
+        emit AccountOnboarded(msg.sender, accountKey);
+    }
+}

package/contracts/onboard/README.md

@@ -0,0 +1,65 @@
+# AccountOnboard
+
+## Overview
+
+The `AccountOnboard` contract is responsible for onboarding user accounts to the system, leveraging RSA public keys and AES encryption. During onboarding, the user's AES encryption key is emitted in an encrypted form. This contract interacts with a utility contract `MpcCore` to retrieve the user key.
+
+## Prerequisites
+
+- **Solidity Version**: `^0.8.19`
+- **License**: MIT
+- **Dependencies**:
+  - Imports from `../utils/mpc/MpcCore.sol`.
+
+## Table of Contents
+- [Events](#events)
+  - [AccountOnboarded](#accountonboarded)
+- [Functions](#functions)
+  - [onboardAccount](#onboardaccount)
+
+## Events
+
+### AccountOnboarded
+
+This event is triggered when a new account is successfully onboarded. It logs the user's account information, including the sender's address and the AES encryption key in its encrypted form.
+
+#### Parameters:
+- **`_from`**: (`address`) The address of the account that initiated the onboarding process.
+- **`userKey`**: (`bytes`) The user's AES encryption key, encrypted using RSA. This key must be decrypted before use.
+
+```solidity
+event AccountOnboarded(address indexed _from, bytes userKey);
+```
+
+## Functions
+
+### onboardAccount
+
+The `onboardAccount` function is responsible for onboarding a new user account. It takes an RSA public key and a signed hash of the key, verifies the credentials, and emits the encrypted AES key.
+
+#### Function Definition:
+
+```solidity
+function onboardAccount(bytes calldata publicKey, bytes calldata signedEK) public;
+```
+
+#### Parameters:
+- **`publicKey`**: (`bytes`) The RSA public key of the user. This is used to verify and generate the AES encryption key.
+- **`signedEK`**: (`bytes`) A signed hash of the RSA public key, used to ensure the authenticity of the public key.
+
+#### Logic:
+1. Calls the external `MpcCore.getUserKey()` function to retrieve the user's AES encryption key using the provided RSA public key and its signed hash.
+2. Emits the `AccountOnboarded` event, logging the caller's address and the encrypted AES key.
+
+#### Example Usage:
+
+```solidity
+function onboardAccount(bytes calldata publicKey, bytes calldata signedEK) public {
+    bytes memory accountKey = MpcCore.getUserKey(publicKey, signedEK);
+    emit AccountOnboarded(msg.sender, accountKey);
+}
+```
+
+### External Function Calls:
+- **`MpcCore.getUserKey(publicKey, signedEK)`**:
+  - Retrieves the user's AES encryption key, based on the RSA public key and signed hash.

package/contracts/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "contracts",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/contracts/token/PrivateERC20/IPrivateERC20.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../utils/mpc/MpcCore.sol";
+
+/**
+ * @dev Interface of the COTI Private ERC-20 standard.
+ */
+interface IPrivateERC20 {
+    struct Allowance {
+        ctUint64 ciphertext;
+        ctUint64 ownerCiphertext;
+        ctUint64 spenderCiphertext;
+    }
+    
+    /**
+     * @dev Emitted when `senderValue/receiverValue` tokens are moved from one account (`from`) to
+     * another (`to`).
+     *
+     * Note that `senderValue/receiverValue` may be zero.
+     */
+    event Transfer(address indexed from, address indexed to, ctUint64 senderValue, ctUint64 receiverValue);
+
+    /**
+     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
+     * a call to {approve}. `ownerValue` and `spenderValue` are the new allowance encrypted with the respective users AES key.
+     */
+    event Approval(address indexed owner, address indexed spender, ctUint64 ownerValue, ctUint64 spenderValue);
+
+    /**
+     * @dev Returns the value of tokens in existence.
+     */
+    function totalSupply() external view returns (uint256);
+
+    /**
+     * @dev Returns the value of tokens owned by `account` encrypted with their AES key.
+     */
+    function balanceOf(address account) external view returns (ctUint64);
+
+    /**
+     * @dev Returns the value of tokens owned by the caller.
+     */
+    function balanceOf() external returns (gtUint64);
+
+    /**
+     * @dev Reencrypts the caller's balance using the AES key of `addr`.
+     */
+    function setAccountEncryptionAddress(address addr) external returns (bool);
+
+    /**
+     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
+     *
+     * Returns an encrypted boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transfer(address to, itUint64 calldata value) external returns (gtBool);
+
+    /**
+     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
+     *
+     * Returns an encrypted boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transfer(address to, gtUint64 value) external returns (gtBool);
+
+    /**
+     * @dev Returns the remaining number of tokens that `spender` will be
+     * allowed to spend on behalf of `owner` through {transferFrom}. This is
+     * zero by default.
+     *
+     * This value changes when {approve} or {transferFrom} are called.
+     */
+    function allowance(address owner, address spender) external view returns (Allowance memory);
+
+    /**
+     * @dev Returns the remaining number of tokens that `account` will be
+     * allowed to spend on behalf of the caller through {transferFrom} (or vice
+     * versa depending on the value of `isSpender`). This is zero by default.
+     *
+     * This value changes when {approve} or {transferFrom} are called.
+     */
+    function allowance(address account, bool isSpender) external returns (gtUint64);
+
+    /**
+     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
+     * caller's tokens.
+     *
+     * Returns an encrypted boolean value indicating whether the operation succeeded.
+     *
+     * IMPORTANT: Beware that changing an allowance with this method brings the risk
+     * that someone may use both the old and the new allowance by unfortunate
+     * transaction ordering. One possible solution to mitigate this race
+     * condition is to first reduce the spender's allowance to 0 and set the
+     * desired value afterwards:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address spender, itUint64 calldata value) external returns (bool);
+
+    /**
+     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
+     * caller's tokens.
+     *
+     * Returns an encrypted boolean value indicating whether the operation succeeded.
+     *
+     * IMPORTANT: Beware that changing an allowance with this method brings the risk
+     * that someone may use both the old and the new allowance by unfortunate
+     * transaction ordering. One possible solution to mitigate this race
+     * condition is to first reduce the spender's allowance to 0 and set the
+     * desired value afterwards:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address spender, gtUint64 value) external returns (bool);
+
+    /**
+     * @dev Moves a `value` amount of tokens from `from` to `to` using the
+     * allowance mechanism. `value` is then deducted from the caller's
+     * allowance.
+     *
+     * Returns an encrypted boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(address from, address to, itUint64 calldata value) external returns (gtBool);
+
+    /**
+     * @dev Moves a `value` amount of tokens from `from` to `to` using the
+     * allowance mechanism. `value` is then deducted from the caller's
+     * allowance.
+     *
+     * Returns an encrypted boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(address from, address to, gtUint64 value) external returns (gtBool);
+}