Gas Costs

// ❌ Expensive: euint64 for vote counter (0-1000)
euint64 voteCount;  // FHE.add costs ~250k gas

// ✅ Efficient: euint16 sufficient
euint16 voteCount;  // FHE.add costs ~120k gas (52% savings)

// ❌ Wasteful
euint256 voteCount;  // 0-100 votes, FHE.add ~600k gas

// ✅ Efficient
euint8 voteCount;    // 0-255 range, FHE.add ~80k gas (87% savings)

Value range 0-255?           -> euint8
Value range 0-65,535?        -> euint16
Value range 0-4.3B?          -> euint32
Value range 0-18 quintillion? -> euint64
Larger?                      -> euint128 or euint256

// ❌ Expensive: Both encrypted
euint32 result = FHE.add(value, FHE.asEuint32(10));  // ~180k gas

// ✅ Cheaper: Plaintext second operand
euint32 result = FHE.add(value, 10);  // ~120k gas (33% savings)

// ❌ Multiple operations (4 FHE ops = ~720k gas)
euint32 a = FHE.add(x, y);
euint32 b = FHE.add(a, z);
euint32 c = FHE.mul(b, 2);

// ✅ Combine operations (2 FHE ops = ~360k gas)
euint32 sum = FHE.add(FHE.add(x, y), z);  // Chain additions
euint32 result = FHE.mul(sum, 2);

// ❌ Recomputes comparison twice (~560k gas)
euint64 r1 = FHE.select(FHE.gt(a, b), x, y);
euint64 r2 = FHE.select(FHE.gt(a, b), m, n);

// ✅ Compute once, reuse (~440k gas)
ebool isGreater = FHE.gt(a, b);  // ~280k gas (once)
euint64 r1 = FHE.select(isGreater, x, y);  // ~160k gas
euint64 r2 = FHE.select(isGreater, m, n);  // ~160k gas

// ❌ Expensive: Multiply by 8
euint32 result = FHE.mul(value, 8);  // ~400k gas

// ✅ Cheaper: Shift left by 3 (2^3 = 8)
euint32 result = FHE.shl(value, 3);  // ~220k gas (45% savings)

// ❌ Expensive: Divide by 4
euint32 result = FHE.div(value, 4);  // ~700k gas

// ✅ Cheaper: Shift right by 2 (2^2 = 4)
euint32 result = FHE.shr(value, 2);  // ~220k gas (69% savings)

// ❌ Verbose: Compare + Select (~440k gas)
ebool isLess = FHE.lt(a, b);         // ~280k gas
euint32 minimum = FHE.select(isLess, a, b);  // ~160k gas

// ✅ Built-in: FHE.min (~450k gas, similar but cleaner)
euint32 minimum = FHE.min(a, b);

// ❌ On-chain computation (3 FHE ops ~760k gas)
function submitOrder(
    externalEuint64 encPrice,
    externalEuint64 encQty,
    externalEuint64 encFee,
    bytes calldata proof
) external {
    euint64 price = FHE.fromExternal(encPrice, proof);
    euint64 qty = FHE.fromExternal(encQty, proof);
    euint64 fee = FHE.fromExternal(encFee, proof);
    euint64 total = FHE.add(FHE.mul(price, qty), fee);  // 2 FHE ops
}

// ✅ Client computes: total = price * qty + fee, sends result
function submitOrder(
    externalEuint64 encTotal,
    bytes calldata proof
) external {
    euint64 total = FHE.fromExternal(encTotal, proof);  // 0 FHE ops
    FHE.allowThis(total);
}

// ❌ Persistent permission (~50k gas)
FHE.allow(tempValue, callback);
ICallback(callback).process(tempValue);

// ✅ Transient permission (~30k gas, 40% savings)
FHE.allowTransient(tempValue, callback);
ICallback(callback).process(tempValue);

// ✅ Organized: All ACL at end
balances[from] = newFromBal;
balances[to] = newToBal;

// Batch ACL calls
FHE.allowThis(balances[from]);
FHE.allow(balances[from], from);
FHE.allowThis(balances[to]);
FHE.allow(balances[to], to);

// ❌ Everything encrypted
euint32 public totalVotes;     // Total count - does this need to be secret?
euint32 public votingDeadline; // Deadline - public info

// ✅ Hybrid approach
uint256 public totalVoters;    // Public count
uint256 public votingDeadline; // Public deadline
euint32 private yesVotes;      // Secret tally
euint32 private noVotes;       // Secret tally

Total Gas = Base (21k)
          + Contract logic
          + Σ(FHE operations)
          + Σ(ACL operations)
          + Σ(Input conversions)

Operation                     | Gas
------------------------------|----------
Base transaction              | 21,000
FHE.fromExternal (euint64)    | 100,000
FHE.ge (balance check)        | 450,000
FHE.sub (sender balance)      | 250,000
FHE.add (receiver balance)    | 250,000
FHE.select (sender)           | 230,000
FHE.select (receiver)         | 230,000
FHE.allowThis x2              | 100,000
FHE.allow x2                  | 100,000
Contract overhead             | 50,000
------------------------------|----------
TOTAL ESTIMATED               | ~1,781,000

// hardhat.config.js
module.exports = {
  networks: {
    hardhat: {
      gas: 30_000_000,
      blockGasLimit: 30_000_000,
    },
  },
};

const tx = await contract.transfer(recipient, encryptedAmount, proof);
const receipt = await tx.wait();
console.log(`Transfer gas used: ${receipt.gasUsed.toString()}`);

npm install hardhat-gas-reporter --save-dev

// hardhat.config.js
require("hardhat-gas-reporter");

module.exports = {
  gasReporter: {
    enabled: true,
    currency: "USD",
  },
};