Contract Functions

constructor() Ownable(msg.sender) {

    _name = "Confidential USD";

    _symbol = "cUSD";

}

// Standard minting with plaintext amount

function mint(uint256 mintedAmount) public virtual onlyOwner {

    balances[owner()] = e.add(

        balances[owner()],

        e.asEuint256(mintedAmount)

    );

    e.allow(balances[owner()], address(this));

    e.allow(balances[owner()], owner());

    _totalSupply += mintedAmount;

    emit Mint(owner(), mintedAmount);

}



// Minting with encrypted amount

function _mint(bytes calldata encryptedAmount) public virtual onlyOwner {

    balances[msg.sender] = e.add(

        balances[msg.sender],

        e.newEuint256(encryptedAmount, msg.sender)

    );

    e.allow(balances[msg.sender], address(this));

    e.allow(balances[msg.sender], owner());

    e.allow(balances[msg.sender], msg.sender);

}

// For EOAs using encrypted inputs

function transfer(

    address to,

    bytes calldata encryptedAmount

) public virtual returns (bool) {

    transfer(to, e.newEuint256(encryptedAmount, msg.sender));

    return true;

}



// For contract interactions

function transfer(

    address to,

    euint256 amount

) public virtual returns (bool) {

    ebool canTransfer = e.ge(balances[msg.sender], amount);

    _transfer(msg.sender, to, amount, canTransfer);

    return true;

}

// Approve for EOAs

function approve(

    address spender,

    bytes calldata encryptedAmount

) public virtual returns (bool) {

    approve(spender, e.newEuint256(encryptedAmount, msg.sender));

    return true;

}



// Approve for contracts

function approve(

    address spender,

    euint256 amount

) public virtual returns (bool) {

    _approve(msg.sender, spender, amount);

    emit Approval(msg.sender, spender);

    return true;

}



// Internal approval logic

function _approve(

    address owner,

    address spender,

    euint256 amount

) internal virtual {

    allowances[owner][spender] = amount;

    e.allow(amount, address(this));

    e.allow(amount, owner);

    e.allow(amount, spender);

}

// TransferFrom for EOAs

function transferFrom(

    address from,

    address to,

    bytes calldata encryptedAmount

) public virtual returns (bool) {

    transferFrom(from, to, e.newEuint256(encryptedAmount, msg.sender));

    return true;

}



// TransferFrom for contracts

function transferFrom(

    address from,

    address to,

    euint256 amount

) public virtual returns (bool) {

    ebool isTransferable = _updateAllowance(from, msg.sender, amount);

    _transfer(from, to, amount, isTransferable);

    return true;

}

// Get encrypted balance

function balanceOf(address wallet) public view virtual returns (euint256) {

    return balances[wallet];

}



// Get encrypted allowance

function allowance(

    address owner,

    address spender

) public view virtual returns (euint256) {

    return _allowance(owner, spender);

}

// Request balance decryption

function requestUserBalanceDecryption(

    address user

) public onlyOwner returns (uint256) {

    euint256 encryptedBalance = balances[user];

    e.allow(encryptedBalance, address(this));



    uint256 requestId = e.requestDecryption(

        encryptedBalance,

        this.onDecryptionCallback.selector,

        ""

    );

    requestIdToUserAddress[requestId] = user;

    return requestId;

}



// Decryption callback

function onDecryptionCallback(

    uint256 requestId,

    bytes32 _decryptedAmount,

    bytes memory data

) public returns (bool) {

    address userAddress = requestIdToUserAddress[requestId];

    emit UserBalanceDecrypted(userAddress, uint256(_decryptedAmount));

    return true;

}