@coti-io/coti-contracts 1.0.0 → 1.0.3

package/contracts/onboard/README.md

@@ -1,65 +0,0 @@
-# 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/token/PrivateERC20/README.md

@@ -1,104 +0,0 @@
-# PrivateERC20
-
-## Overview
-
-The `PrivateERC20` contract is an abstract implementation of a privacy-enhanced ERC20 token. It introduces mechanisms for handling encrypted addresses and balances, allowing for more secure and private token transfers. This contract builds on top of OpenZeppelin's `Context` and the `IPrivateERC20` interface, and it integrates with the `MpcCore` library for secure multiparty computation (MPC).
-
-## Prerequisites
-
-- **Solidity Version**: `^0.8.19`
-- **License**: MIT
-- **Dependencies**:
-  - OpenZeppelin's `Context` contract
-  - Interface `IPrivateERC20`
-  - Utility `MpcCore` for cryptographic operations.
-
-## Table of Contents
-- [Constants](#constants)
-  - [MAX_UINT_64](#max_uint_64)
-- [State Variables](#state-variables)
-  - [Account Encryption Address Mapping](#account-encryption-address-mapping)
-  - [Balance Mapping](#balance-mapping)
-  - [Allowances Mapping](#allowances-mapping)
-  - [Total Supply](#total-supply)
-  - [Token Name and Symbol](#token-name-and-symbol)
-- [Errors](#errors)
-  - [ERC20InvalidSender](#erc20invalidsender)
-  - [ERC20InvalidReceiver](#erc20invalidreceiver)
-- [Functions](#functions)
-  - To be documented as additional logic is discovered.
-
-## Constants
-
-### MAX_UINT_64
-
-```solidity
-uint64 private constant MAX_UINT_64 = type(uint64).max;
-```
-
-The constant `MAX_UINT_64` represents the maximum value of a 64-bit unsigned integer. This is used as a cap for various operations in the contract.
-
-## State Variables
-
-### Account Encryption Address Mapping
-
-```solidity
-mapping(address account => address) private _accountEncryptionAddress;
-```
-
-This mapping associates each account (public address) with an encryption address. The encryption address could be used for handling cryptographically secure operations involving private balances and transactions.
-
-### Balance Mapping
-
-```solidity
-mapping(address account => utUint64) private _balances;
-```
-
-The `_balances` mapping keeps track of each account's token balance, but it uses a 64-bit unsigned integer (`utUint64`). This might be intended for scaling or privacy-preserving reasons.
-
-### Allowances Mapping
-
-```solidity
-mapping(address account => mapping(address spender => Allowance)) private _allowances;
-```
-
-The `_allowances` mapping tracks the allowance that one account (`account`) has given to another account (`spender`). This is a standard ERC20 allowance mechanism with the added layer of the `Allowance` structure, which may handle encrypted or privacy-preserving amounts.
-
-### Total Supply
-
-```solidity
-ctUint64 private _totalSupply;
-```
-
-The `_totalSupply` variable keeps track of the total number of tokens in existence. Like the `_balances` mapping, it uses a 64-bit unsigned integer (`ctUint64`).
-
-### Token Name and Symbol
-
-```solidity
-string private _name;
-string private _symbol;
-```
-
-These variables store the name and symbol of the token, following the ERC20 standard.
-
-## Errors
-
-### ERC20InvalidSender
-
-```solidity
-error ERC20InvalidSender(address sender);
-```
-
-The `ERC20InvalidSender` error is raised when an invalid sender address attempts to perform a token transfer. It logs the `sender` address that caused the failure.
-
-### ERC20InvalidReceiver
-
-```solidity
-error ERC20InvalidReceiver(address receiver);
-```
-
-The `ERC20InvalidReceiver` error is raised when a transfer fails due to an invalid receiver address. It logs the `receiver` address that caused the failure.
-
-## Functions
-
-Functions in the contract are abstract or unimplemented in this fragment. These likely involve ERC20-style operations, such as `transfer`, `approve`, and `transferFrom`, but with privacy-preserving adjustments, including the handling of encrypted addresses and balances.

package/contracts/token/PrivateERC721/README.md

@@ -1,282 +0,0 @@
-# PrivateERC721
-
-## Overview
-
-`PrivateERC721` is an abstract implementation of the [ERC721 Non-Fungible Token (NFT) Standard](https://eips.ethereum.org/EIPS/eip-721). It includes essential features of the standard, such as token ownership, approval, transfers, and safe transfers. This contract implements key components of the ERC721 standard while maintaining support for token metadata, but without fully implementing the metadata extension.
-
-## Prerequisites
-
-- **Solidity Version**: `^0.8.19`
-- **License**: MIT
-- **Dependencies**:
-  - OpenZeppelin’s `Context`, `ERC165`, and `IERC721` contracts.
-  - `IERC721Receiver` for safe transfer checks.
-  - `IERC721Errors` interface for custom errors (related to the draft standard [IERC6093](https://eips.ethereum.org/EIPS/eip-6093)).
-
-## Table of Contents
-- [Events](#events)
-- [State Variables](#state-variables)
-- [Constructor](#constructor)
-- [Functions](#functions)
-  - [Supports Interface](#supports-interface)
-  - [Balance Of](#balance-of)
-  - [Owner Of](#owner-of)
-  - [Name](#name)
-  - [Symbol](#symbol)
-  - [Approve](#approve)
-  - [Get Approved](#get-approved)
-  - [Set Approval For All](#set-approval-for-all)
-  - [Is Approved For All](#is-approved-for-all)
-  - [Transfer From](#transfer-from)
-  - [Safe Transfer From](#safe-transfer-from)
-  - [Private/Internal Functions](#privateinternal-functions)
-
-## Events
-
-## Event: `Transfer`
-
-```solidity
-event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
-```
-
-### Description:
-This event is emitted whenever an ERC-721 token is transferred from one address to another. It occurs during both direct token transfers (`transferFrom`) and safe token transfers (`safeTransferFrom`). This event helps external observers, such as dApps and explorers, to track the movement of tokens.
-
-### Parameters:
-- **`from`** (`address`): The address of the current owner of the token.
-- **`to`** (`address`): The address that is receiving ownership of the token.
-- **`tokenId`** (`uint256`): The unique identifier (ID) of the token being transferred.
-
-### Important Notes:
-- This event is emitted for both `transferFrom` and `safeTransferFrom` operations.
-- If a token is minted, `from` will be the zero address (`address(0)`).
-- If a token is burned, `to` will be the zero address (`address(0)`).
-
-## Event: `Approval`
-
-```solidity
-event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
-```
-
-### Description:
-The `Approval` event is emitted when an owner grants or revokes permission to another account (the `approved` address) to transfer a specific token. Each ERC-721 token can only have one approved address at a time. The approval is reset when the token is transferred to a new owner.
-
-### Parameters:
-- **`owner`** (`address`): The current owner of the token.
-- **`approved`** (`address`): The address that is approved to transfer the token. This can be the zero address (`address(0)`) if no account is approved.
-- **`tokenId`** (`uint256`): The unique identifier (ID) of the token being approved for transfer.
-
-### Important Notes:
-- This event is specific to individual tokens, meaning approvals apply to a single `tokenId`.
-- Approving the zero address (`address(0)`) clears the previous approval, effectively revoking approval for that token.
-
-## Event: `ApprovalForAll`
-
-```solidity
-event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
-```
-
-### Description:
-This event is emitted when an owner enables or disables an operator to manage all of their assets. Operators can transfer or manage any token owned by the `owner`. The event allows for bulk approval of all tokens owned by a single account.
-
-### Parameters:
-- **`owner`** (`address`): The address of the token owner.
-- **`operator`** (`address`): The address that is granted or revoked permission to manage all of the owner's tokens.
-- **`approved`** (`bool`): A boolean value indicating whether the operator is approved (`true`) or approval is revoked (`false`).
-
-### Important Notes:
-- This event differs from the `Approval` event because it applies to all tokens owned by the `owner`, not a single token.
-- This event is emitted when the `setApprovalForAll` function is called, allowing or revoking an operator’s access to all of the owner's tokens.
-
-## State Variables
-
-- **_name** (`string`): The name of the token collection.
-- **_symbol** (`string`): The symbol for the token collection.
-- **_owners** (`mapping(uint256 => address)`): Maps a token ID to its owner address.
-- **_balances** (`mapping(address => uint256)`): Maps owner addresses to the number of tokens they own.
-- **_tokenApprovals** (`mapping(uint256 => address)`): Maps a token ID to the approved address for that token.
-- **_operatorApprovals** (`mapping(address => mapping(address => bool))`): Maps an owner to an operator, allowing the operator to manage all tokens owned by that owner.
-
-## Constructor
-
-```solidity
-constructor(string memory name_, string memory symbol_)
-```
-
-The constructor initializes the contract by setting the name and symbol of the token collection. It accepts the following parameters:
-
-- **`name_`**: The name of the token collection.
-- **`symbol_`**: The symbol for the token collection.
-
-## Functions
-
-### Supports Interface
-
-```solidity
-function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool)
-```
-
-Implements the `supportsInterface` function to check if the contract implements a specific interface (e.g., `IERC721`).
-
-- **`interfaceId`**: The interface identifier to check.
-- **Returns**: `true` if the contract supports the interface, otherwise `false`.
-
-### Balance Of
-
-```solidity
-function balanceOf(address owner) public view virtual returns (uint256)
-```
-
-Returns the number of tokens owned by the given address.
-
-- **`owner`**: The address to query.
-- **Returns**: The number of tokens owned by the address.
-- **Reverts**: `ERC721InvalidOwner` if `owner` is the zero address.
-
-### Owner Of
-
-```solidity
-function ownerOf(uint256 tokenId) public view virtual returns (address)
-```
-
-Returns the owner of the given `tokenId`.
-
-- **`tokenId`**: The ID of the token.
-- **Returns**: The owner address of the `tokenId`.
-- **Reverts**: If the token does not exist.
-
-### Name
-
-```solidity
-function name() public view virtual returns (string memory)
-```
-
-Returns the name of the token collection.
-
-### Symbol
-
-```solidity
-function symbol() public view virtual returns (string memory)
-```
-
-Returns the symbol of the token collection.
-
-### Approve
-
-```solidity
-function approve(address to, uint256 tokenId) public virtual
-```
-
-Approves the given address (`to`) to transfer the specified token on behalf of the owner.
-
-- **`to`**: The address to be approved.
-- **`tokenId`**: The ID of the token to approve.
-
-### Get Approved
-
-```solidity
-function getApproved(uint256 tokenId) public view virtual returns (address)
-```
-
-Returns the approved address for the given `tokenId`.
-
-- **`tokenId`**: The ID of the token to check.
-- **Returns**: The address approved to transfer the `tokenId`.
-
-### Set Approval For All
-
-```solidity
-function setApprovalForAll(address operator, bool approved) public virtual
-```
-
-Enables or disables approval for a third-party `operator` to manage all tokens owned by the sender.
-
-- **`operator`**: The address of the operator.
-- **`approved`**: `true` to approve, `false` to revoke approval.
-
-### Is Approved For All
-
-```solidity
-function isApprovedForAll(address owner, address operator) public view virtual returns (bool)
-```
-
-Checks if the `operator` is approved to manage all tokens owned by `owner`.
-
-- **`owner`**: The address of the token owner.
-- **`operator`**: The address of the operator.
-- **Returns**: `true` if the operator is approved, otherwise `false`.
-
-### Transfer From
-
-```solidity
-function transferFrom(address from, address to, uint256 tokenId) public virtual
-```
-
-Transfers ownership of the `tokenId` from one address to another.
-
-- **`from`**: The current owner of the token.
-- **`to`**: The address receiving the token.
-- **`tokenId`**: The ID of the token.
-- **Reverts**: `ERC721InvalidReceiver` if `to` is the zero address or if the sender is not authorized to transfer the token.
-
-### Safe Transfer From
-
-```solidity
-function safeTransferFrom(address from, address to, uint256 tokenId) public
-```
-
-Safely transfers a `tokenId` from one address to another, ensuring the receiver can handle ERC721 tokens.
-
-- **`from`**: The current owner of the token.
-- **`to`**: The address receiving the token.
-- **`tokenId`**: The ID of the token.
-
-### Private/Internal Functions
-
-#### `_ownerOf`
-
-```solidity
-function _ownerOf(uint256 tokenId) internal view virtual returns (address)
-```
-
-Internal function that returns the owner of the `tokenId`.
-
-#### `_isAuthorized`
-
-```solidity
-function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool)
-```
-
-Checks if `spender` is authorized to manage `owner`'s token or the specific `tokenId`.
-
-#### `_approve`
-
-```solidity
-function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual
-```
-
-Approves the address `to` to manage the `tokenId`. Optionally emits the `Approval` event.
-
-#### `_mint`
-
-```solidity
-function _mint(address to, uint256 tokenId) internal
-```
-
-Mints a new token with the given `tokenId` and transfers it to the address `to`.
-
-#### `_burn`
-
-```solidity
-function _burn(uint256 tokenId) internal
-```
-
-Burns (destroys) the token with the given `tokenId`.
-
-#### `_checkOnERC721Received`
-
-```solidity
-function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private
-```
-
-Private function to invoke the `IERC721Receiver.onERC721Received` on the target address if it's a contract.

package/contracts/utils/mpc/README.md

@@ -1,82 +0,0 @@
-# MpcCore.sol
-
-This Solidity library, `MpcCore`, provides core functionalities for secure multi-party computation (MPC) using the COTI protocol. Below is an overview of its components and functions:
-
-## Legend
-
-- it = input text. This structure contains text that was encrypted by user and provided a signature to authenticate it.
-- gc = garbled text
-- ct = cipher text
-- ut = user text. This structure  contains 2 types of cipher texts: one by the network and one by the user key. Convenient for operations that require some times to decipher one or another.
-
-## Types
-The library defines several custom types using `uint256` as the base type:
-- `gtBool`, `gtUint8`, `gtUint16`, `gtUint32`, `gtUint64`
-- `ctBool`, `ctUint8`, `ctUint16`, `ctUint32`, `ctUint64`
-- `lenghts`, use to differentiate the length
-
-## Structures
-The library defines multiple structures for handling encrypted and signed data:
-- `itBool`, `itUint8`, `itUint16`, `itUint32`, `itUint64`: Each structure contains a inputtext (`ctBool`, `ctUint8`, etc.) and a signature (`bytes`).
-- `utBool`, `utUint8`, `utUint16`, `utUint32`, `utUint64`: Each structure contains two usertext (`ctBool`, `ctUint8`, etc.) for user and regular data.
-
-## Enums
-- `MPC_TYPE`: Enum to represent different MPC data types (`SBOOL_T`, `SUINT8_T`, `SUINT16_T`, `SUINT32_T`, `SUINT64_T`).
-- `ARGS`: Enum to represent different argument types (`BOTH_SECRET`, `LHS_PUBLIC`, `RHS_PUBLIC`).
-
-## Functions
-### Enum Combination Functions
-These functions combine enum values into bytes for efficient storage and transfer:
-- `combineEnumsToBytes2(MPC_TYPE mpcType, ARGS argsType)`: Combines an `MPC_TYPE` and `ARGS` into a `bytes2` value.
-- `combineEnumsToBytes3(MPC_TYPE mpcType1, MPC_TYPE mpcType2, ARGS argsType)`: Combines two `MPC_TYPE` values and an `ARGS` value into a `bytes3` value.
-- `combineEnumsToBytes4(MPC_TYPE mpcType1, MPC_TYPE mpcType2, MPC_TYPE mpcType3, ARGS argsType)`: Combines three `MPC_TYPE` values and an `ARGS` value into a `bytes4` value.
-
-### Key Management Functions
-- `getUserKey(bytes calldata signedEK, bytes calldata signature)`: Retrieves the user's AES encryption key in encrypted format, by using the provided public key to encrypt it - signature is used to validate the account ownership.
-
-This library is designed to be used as part of a secure multi-party computation framework, facilitating the handling and combination of encrypted and signed data types.
-
-# MpcInterface.sol
-
-This Solidity interface, `ExtendedOperations`, defines a set of functions for performing various operations that are essential for secure multi-party computation (MPC) on the COTI network. Below is an overview of its components and functions:
-
-## Functions
-
-### Onboarding and Offboarding Functions
-- `OnBoard(bytes1 metaData, uint256 ct)`: Onboards a new EOA. Metadata is used to define what is the data type being used (8 , 16, 32 , 64). This function is not directly called by others in MpcCore.
-- `OffBoard(bytes1 metaData, uint256 ct)`: Offboards an EOA. Metadata is used to define what is the data type being used (8 , 16, 32 , 64). This function is not directly called by others in MpcCore.
-- `OffBoardToUser(bytes1 metaData, uint256 ct, bytes calldata addr)`: Offboards an EOA to a user-specified address. Metadata is used to define what is the data type being used (8 , 16, 32 , 64). This function is not directly called by others in MpcCore.
-- `SetPublic(bytes1 metaData, uint256 ct)`: Sets the data as public with the given metadata and ciphertext.
-
-### Randomness Functions
-- `Rand(bytes1 metaData)`: Generates a random value with the given metadata.
-- `RandBoundedBits(bytes1 metaData, uint8 numBits)`: Generates a random value with a specified number of bits.
-
-### Arithmetic Functions
-- `Add(bytes3 metaData, uint256 lhs, uint256 rhs)`: Adds two values.
-- `Sub(bytes3 metaData, uint256 lhs, uint256 rhs)`: Subtracts the second value from the first.
-- `Mul(bytes3 metaData, uint256 lhs, uint256 rhs)`: Multiplies two values.
-- `Div(bytes3 metaData, uint256 lhs, uint256 rhs)`: Divides the first value by the second.
-- `Rem(bytes3 metaData, uint256 lhs, uint256 rhs)`: Computes the remainder of the division of two values.
-
-### Bitwise Functions
-- `And(bytes3 metaData, uint256 lhs, uint256 rhs)`: Performs a bitwise AND operation.
-- `Or(bytes3 metaData, uint256 lhs, uint256 rhs)`: Performs a bitwise OR operation.
-- `Xor(bytes3 metaData, uint256 lhs, uint256 rhs)`: Performs a bitwise XOR operation.
-- `Shl(bytes3 metaData, uint256 lhs, uint256 rhs)`: Performs a bitwise shift left operation.
-- `Shr(bytes3 metaData, uint256 lhs, uint256 rhs)`: Performs a bitwise shift right operation.
-
-### Comparison Functions
-- `Eq(bytes3 metaData, uint256 lhs, uint256 rhs)`: Checks if two values are equal.
-- `Ne(bytes3 metaData, uint256 lhs, uint256 rhs)`: Checks if two values are not equal.
-- `Ge(bytes3 metaData, uint256 lhs, uint256 rhs)`: Checks if the first value is greater than or equal to the second.
-- `Gt(bytes3 metaData, uint256 lhs, uint256 rhs)`: Checks if the first value is greater than the second.
-- `Le(bytes3 metaData, uint256 lhs, uint256 rhs)`: Checks if the first value is less than or equal to the second.
-- `Lt(bytes3 metaData, uint256 lhs, uint256 rhs)`: Checks if the first value is less than the second.
-
-### Validation and Transfer Functions
-- `ValidateCiphertext(bytes calldata ciphertext, bytes calldata signature)`: Validates the given ciphertext and signature.
-    - If the input is not valid, the call will revert with no return data and no additional gas will be consumed.
-- `TransferWithAllowance(address from, address to, uint256 amount, bytes calldata signature)`: Transfers the specified amount from one address to another with the provided signature.
-
-This interface is designed to be implemented by a contract that performs secure multi-party computation, providing essential operations such as arithmetic, bitwise, and comparison functions, as well as onboarding and offboarding participants or data.