chore: add realistic USDT mock with approve-to-zero quirk (#26)

Author: melanciani

contracts/confidential-token-wrappers-registry/contracts/mocks/USDTMock.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.20;
+
+import {ERC20Mock} from "./ERC20Mock.sol";
+
+/**
+ * @title USDTMock
+ * @dev A more realistic USDT mock that replicates the real USDT's approve quirk:
+ * to change a non-zero allowance, it must first be reset to 0.
+ */
+contract USDTMock is ERC20Mock {
+    constructor() ERC20Mock("Tether USD (Mock)", "USDTMock", 6) {}
+
+    /**
+     * @dev Overrides the approve function to require that the allowance is first reset to 0
+     * before setting a new non-zero value. This replicates the real USDT behavior.
+     */
+    function approve(address spender, uint256 value) public override returns (bool) {
+        require(!(value != 0 && allowance(msg.sender, spender) != 0));
+        return super.approve(spender, value);
+    }
+}

contracts/confidential-token-wrappers-registry/tasks/mocks/deployMocks.ts

@@ -2,6 +2,7 @@ import { task, types } from 'hardhat/config';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
 
 const ERC20_MOCK_CONTRACT_NAME = 'ERC20Mock';
+const USDT_MOCK_CONTRACT_NAME = 'USDTMock';
 
 // Deploy the ERC20Mock contract
 async function deployERC20Mock(hre: HardhatRuntimeEnvironment, name: string, symbol: string, decimals: number) {
@@ -38,6 +39,39 @@ async function deployERC20Mock(hre: HardhatRuntimeEnvironment, name: string, sym
   return contractAddress;
 }
 
+// Deploy the USDTMock contract
+async function deployUSDTMock(hre: HardhatRuntimeEnvironment) {
+  const { getNamedAccounts, ethers, deployments, network } = hre;
+  const { save, getArtifact } = deployments;
+
+  const { deployer } = await getNamedAccounts();
+  const deployerSigner = await ethers.getSigner(deployer);
+
+  const factory = await ethers.getContractFactory(USDT_MOCK_CONTRACT_NAME, deployerSigner);
+  const contract = await factory.deploy();
+  await contract.waitForDeployment();
+
+  const contractAddress = await contract.getAddress();
+
+  console.log(
+    [
+      `✅ Deployed USDTMock:`,
+      `  - Address: ${contractAddress}`,
+      `  - Deployed by deployer account: ${deployer}`,
+      `  - Network: ${network.name}`,
+      '',
+    ].join('\n'),
+  );
+
+  const artifact = await getArtifact(USDT_MOCK_CONTRACT_NAME);
+  await save(USDT_MOCK_CONTRACT_NAME, {
+    address: contractAddress,
+    abi: artifact.abi,
+  });
+
+  return contractAddress;
+}
+
 // Deploy the ERC20Mock contract
 // Example usage:
 // npx hardhat task:deployERC20Mock --name "Mock Token" --symbol "MTK" --decimals 18 --network testnet
@@ -52,3 +86,14 @@ task('task:deployERC20Mock')
 
     console.log('✅ ERC20Mock contract deployed\n');
   });
+
+// Deploy the USDTMock contract (realistic USDT with "approve to 0 first" quirk)
+// Example usage:
+// npx hardhat task:deployUSDTMock --network testnet
+task('task:deployUSDTMock').setAction(async function (_, hre) {
+  console.log('Deploying USDTMock contract...\n');
+
+  await deployUSDTMock(hre);
+
+  console.log('✅ USDTMock contract deployed\n');
+});

contracts/confidential-token-wrappers-registry/tasks/mocks/verify.ts

@@ -18,3 +18,19 @@ task('task:verifyMockERC20')
     });
     console.log(`Mock ERC20 contract verification complete\n`);
   });
+
+// Verify the USDTMock contract
+// Example usage:
+// npx hardhat task:verifyUSDTMock --contract-address 0x1234567890123456789012345678901234567890 --network testnet
+task('task:verifyUSDTMock')
+  .addParam('contractAddress', 'The address of the USDTMock contract to verify', '', types.string)
+  .setAction(async function ({ contractAddress }, hre) {
+    const { run } = hre;
+
+    console.log(`Verifying USDTMock contract at ${contractAddress}...\n`);
+    await run('verify:verify', {
+      address: contractAddress,
+      constructorArguments: [],
+    });
+    console.log(`USDTMock contract verification complete\n`);
+  });

contracts/confidential-token-wrappers-registry/test/mocks.test.ts

@@ -0,0 +1,77 @@
+import { expect } from 'chai';
+import { ethers } from 'hardhat';
+
+describe('ERC20Mock', function () {
+  beforeEach(async function () {
+    const [deployer, alice, bob] = await ethers.getSigners();
+    const ERC20Mock = await ethers.getContractFactory('ERC20Mock');
+    const token = await ERC20Mock.deploy('Mock Token', 'MTK', 18);
+    await token.waitForDeployment();
+    Object.assign(this, { token, deployer, alice, bob });
+  });
+
+  it('should support custom decimals', async function () {
+    const ERC20Mock = await ethers.getContractFactory('ERC20Mock');
+    const token6 = await ERC20Mock.deploy('Six Decimals', 'SIX', 6);
+    expect(await token6.decimals()).to.equal(6);
+  });
+
+  it('should mint tokens', async function () {
+    const amount = ethers.parseUnits('1000', 18);
+    await this.token.mint(this.alice.address, amount);
+    expect(await this.token.balanceOf(this.alice.address)).to.equal(amount);
+  });
+
+  it('should revert if mint amount exceeds max', async function () {
+    const maxAmount = ethers.parseUnits('1000000', 18);
+    const tooMuch = maxAmount + 1n;
+    await expect(this.token.mint(this.alice.address, tooMuch))
+      .to.be.revertedWithCustomError(this.token, 'MintAmountExceedsMax')
+      .withArgs(tooMuch, maxAmount);
+  });
+});
+
+describe('USDTMock', function () {
+  beforeEach(async function () {
+    const [deployer, alice, bob] = await ethers.getSigners();
+    const USDTMock = await ethers.getContractFactory('USDTMock');
+    const usdt = await USDTMock.deploy();
+    await usdt.waitForDeployment();
+    Object.assign(this, { usdt, deployer, alice, bob });
+  });
+
+  it('should have correct name, symbol, and decimals', async function () {
+    expect(await this.usdt.name()).to.equal('Tether USD (Mock)');
+    expect(await this.usdt.symbol()).to.equal('USDTMock');
+    expect(await this.usdt.decimals()).to.equal(6);
+  });
+
+  it('should approve from zero allowance', async function () {
+    const amount = ethers.parseUnits('100', 6);
+    await this.usdt.connect(this.alice).approve(this.bob.address, amount);
+    expect(await this.usdt.allowance(this.alice.address, this.bob.address)).to.equal(amount);
+  });
+
+  it('should approve to zero', async function () {
+    const amount = ethers.parseUnits('100', 6);
+    await this.usdt.connect(this.alice).approve(this.bob.address, amount);
+    await this.usdt.connect(this.alice).approve(this.bob.address, 0);
+    expect(await this.usdt.allowance(this.alice.address, this.bob.address)).to.equal(0);
+  });
+
+  it('should revert when changing non-zero allowance to non-zero', async function () {
+    const amount1 = ethers.parseUnits('100', 6);
+    const amount2 = ethers.parseUnits('200', 6);
+    await this.usdt.connect(this.alice).approve(this.bob.address, amount1);
+    await expect(this.usdt.connect(this.alice).approve(this.bob.address, amount2)).to.be.revertedWithoutReason();
+  });
+
+  it('should allow setting new allowance after resetting to zero', async function () {
+    const amount1 = ethers.parseUnits('100', 6);
+    const amount2 = ethers.parseUnits('200', 6);
+    await this.usdt.connect(this.alice).approve(this.bob.address, amount1);
+    await this.usdt.connect(this.alice).approve(this.bob.address, 0);
+    await this.usdt.connect(this.alice).approve(this.bob.address, amount2);
+    expect(await this.usdt.allowance(this.alice.address, this.bob.address)).to.equal(amount2);
+  });
+});