only one my confidential erc20

Author: poppyseedDev

hardhat/contracts/MyConfidentialERC20.sol

@@ -4,43 +4,17 @@ pragma solidity ^0.8.24;
 
 import "fhevm/lib/TFHE.sol";
 import "fhevm/config/ZamaFHEVMConfig.sol";
-import "fhevm/config/ZamaGatewayConfig.sol";
-import "fhevm/gateway/GatewayCaller.sol";
-import "fhevm-contracts/contracts/token/ERC20/extensions/ConfidentialERC20Mintable.sol";
+import "fhevm-contracts/contracts/token/ERC20/extensions/ConfidentialERC20WithErrorsMintable.sol";
 
 /// @notice This contract implements an encrypted ERC20-like token with confidential balances using Zama's FHE library.
 /// @dev It supports typical ERC20 functionality such as transferring tokens, minting, and setting allowances,
 /// @dev but uses encrypted data types.
-contract MyConfidentialERC20 is
-    SepoliaZamaFHEVMConfig,
-    SepoliaZamaGatewayConfig,
-    GatewayCaller,
-    ConfidentialERC20Mintable
-{
-    // @note `SECRET` is not so secret, since it is trivially encrypted and just to have a decryption test
-    euint64 internal immutable SECRET;
-
-    // @note `revealedSecret` will hold the decrypted result once the Gateway will relay the decryption of `SECRET`
-    uint64 public revealedSecret;
-
+contract MyConfidentialERC20 is SepoliaZamaFHEVMConfig, ConfidentialERC20WithErrorsMintable {
     /// @notice Constructor to initialize the token's name and symbol, and set up the owner
     /// @param name_ The name of the token
     /// @param symbol_ The symbol of the token
-    constructor(string memory name_, string memory symbol_) ConfidentialERC20Mintable(name_, symbol_, msg.sender) {
-        SECRET = TFHE.asEuint64(42);
-        TFHE.allowThis(SECRET);
-    }
-
-    /// @notice Request decryption of `SECRET`
-    function requestSecret() public {
-        uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(SECRET);
-        Gateway.requestDecryption(cts, this.callbackSecret.selector, 0, block.timestamp + 100, false);
-    }
-
-    /// @notice Callback function for `SECRET` decryption
-    /// @param `decryptedValue` The decrypted 64-bit unsigned integer
-    function callbackSecret(uint256, uint64 decryptedValue) public onlyGateway {
-        revealedSecret = decryptedValue;
-    }
+    constructor(
+        string memory name_,
+        string memory symbol_
+    ) ConfidentialERC20WithErrorsMintable(name_, symbol_, msg.sender) {}
 }

hardhat/contracts/auctions/MyConfidentialERC20.sol

@@ -14,13 +14,10 @@ contract EncryptedCounter4 is SepoliaZamaFHEVMConfig {
     mapping(address => euint8) private counters;
 
     function incrementBy(einput amount, bytes calldata inputProof) public {
-        // Initialize counter if it doesn't exist
-        counters[msg.sender] = TFHE.asEuint8(0);
-
         // Convert input to euint8 and add to sender's counter
         euint8 incrementAmount = TFHE.asEuint8(amount, inputProof);
         counters[msg.sender] = TFHE.add(counters[msg.sender], incrementAmount);
-        TFHE.allowThis(counters[msg.sender]);
+        TFHE.allow(counters[msg.sender], address(this));
         TFHE.allow(counters[msg.sender], msg.sender);
     }
 

hardhat/contracts/confidentialCounter/sample4.sol

@@ -1,12 +1,12 @@
 import { ethers } from "hardhat";
 
-import type { BlindAuctionConfidentialERC20 } from "../../types";
+import type { MyConfidentialERC20 } from "../../types";
 import { getSigners } from "../signers";
 
-export async function deployConfidentialERC20Fixture(): Promise<BlindAuctionConfidentialERC20> {
+export async function deployConfidentialERC20Fixture(): Promise<MyConfidentialERC20> {
   const signers = await getSigners();
 
-  const contractFactory = await ethers.getContractFactory("BlindAuctionConfidentialERC20");
+  const contractFactory = await ethers.getContractFactory("MyConfidentialERC20");
   const contract = await contractFactory.connect(signers.alice).deploy("Naraggara", "NARA"); // City of Zama's battle
   await contract.waitForDeployment();
 

hardhat/test/blindAuction/ConfidentialERC20.fixture.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 import { network } from "hardhat";
 
-import { awaitAllDecryptionResults, initGateway } from "../asyncDecrypt";
+import { initGateway } from "../asyncDecrypt";
 import { createInstance } from "../instance";
 import { reencryptEuint64 } from "../reencrypt";
 import { getSigners, initSigners } from "../signers";
@@ -180,14 +180,6 @@ describe("ConfidentialERC20", function () {
     expect(balanceBob2).to.equal(1337); // check that transfer did happen this time
   });
 
-  it("should decrypt the SECRET value", async function () {
-    const tx2 = await this.erc20.requestSecret();
-    await tx2.wait();
-    await awaitAllDecryptionResults();
-    const y = await this.erc20.revealedSecret();
-    expect(y).to.equal(42n);
-  });
-
   it("DEBUG - using debug.decrypt64 for debugging transfer", async function () {
     if (network.name === "hardhat") {
       // using the debug.decryptXX functions is possible only in mocked mode

hardhat/test/confidentialERC20/ConfidentialERC20.ts

@@ -122,6 +122,7 @@ describe("FHEwordle contract via proxy via FHEwordleFactory", function () {
   before(async function () {
     await initSigners();
     this.signers = await getSigners();
+    await initGateway();
   });
 
   beforeEach(async function () {