Solidity 隐私代币揭秘：自动回调与操作员机制详解

目录

• 引言
• 一、Operator
• • • 代码解释
• 二、Callback
• • • 发送方合约（Token 合约）
    • 接收方合约（Receiver）
    • 代码解释
• 三、Swaps
• • （一）Swap ERC20 to ConfidentialFungibleToken
  • 代码解释
  • • 1、函数签名及参数
    • 2、扣除用户明文代币
    • 3、铸造对应加密代币
  • （二）Swap ConfidentialFungibleToken to ConfidentialFungibleToken
  • • 代码解释
  • （三）Swap ConfidentialFungibleToken to ERC20
  • • 代码解释
• 总结

引言

在以太坊智能合约的开发中，传统的代币转账方式通常依赖于用户直接调用 transfer 或 transferFrom 方法。然而，这种方式在某些场景下可能不够灵活，尤其是当需要第三方代表用户执行代币操作时。为了解决这一问题，引入了“操作员（Operator）”机制，使得用户可以授权第三方在特定条件下代表自己进行代币操作。

在 OpenZeppelin 的 Confidential Fungible Token（CFT）实现中，除了传统的转账方式，还引入了带回调（callback）的转账函数 confidentialTransferWithCallback。这种方式允许在代币转账完成后，自动触发接收方合约的特定函数，从而实现更复杂的业务逻辑。

本文将详细介绍操作员机制的实现方式，以及带回调的转账函数如何在发送方和接收方合约中协同工作，实现代币的安全转移和自动处理。

一、Operator

在标准的 ERC-20 代币合约中，用户只能直接调用 transfer 和 transferFrom 方法来转移代币。然而，在某些场景下，我们希望允许第三方代表用户进行代币转移操作，这时就引入了操作员机制。操作员是被授权代表用户执行特定操作的地址，通常具有一定的权限和有效期限。

const alice: Wallet;
const expirationTimestamp = Math.round(Date.now() / 1000) + 60 * 60 * 24; // 当前时间 + 24 小时

await tokenContract.connect(alice).setOperator(bob, expirationTimestamp);

代码解释

创建一个钱包实例 alice，用于签名交易。 计算当前时间加上 24 小时后的时间戳，作为操作权限的过期时间。 通过 alice 钱包连接到代币合约，并调用 setOperator 方法，将 bob 设置为操作员，权限在指定的时间戳后过期。

二、Callback

回调就是转账完成后，“自动触发”对接收方合约的特定函数进行调用。 如果你选择使用带回调的转账函数，就不需要再手动调用中间授权（如“操作员审批”）步骤，系统会自动处理。

被回调函数调用的智能合约必须实现 IConfidentialFungibleTokenReceiver 接口。

发送方合约（Token 合约）

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {IConfidentialFungibleTokenReceiver} from "@openzeppelin/confidential-contracts/interfaces/IConfidentialFungibleTokenReceiver.sol";
import {ConfidentialFungibleToken} from "@openzeppelin/confidential-contracts/token/ConfidentialFungibleToken.sol";

contract ConfidentialToken is ConfidentialFungibleToken {
constructor() ConfidentialFungibleToken("ConfidentialToken", "CFT") {}

function confidentialTransferWithCallback(
address recipient,
externalEuint64 encryptedAmount,
bytes calldata inputProof,
bytes calldata callbackData
) external {
confidentialTransferFrom(msg.sender, address(this), encryptedAmount, inputProof);

bool success = IConfidentialFungibleTokenReceiver(recipient)
.onConfidentialTransferReceived(
msg.sender,
encryptedAmount,
callbackData
);

require(success, "Callback failed");
}
}

接收方合约（Receiver）

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {IConfidentialFungibleTokenReceiver} from "@openzeppelin/confidential-contracts/interfaces/IConfidentialFungibleTokenReceiver.sol";

contract Receiver is IConfidentialFungibleTokenReceiver {
mapping(address => uint256) public balances;

function onConfidentialTransferReceived(
address from,
bytes calldata ciphertext,
bytes calldata data
) external override returns (ebool) {
uint256 decryptedAmount = 100; // 假设解密后的金额为 100
balances[from] += decryptedAmount;
return true;
}
}

代码解释

发送方调用 confidentialTransferWithCallback：将加密金额转账给接收方合约。

Token 合约自动调用回调函数：在转账完成后，自动调用接收方合约的 onConfidentialTransferReceived 方法。

接收方合约处理回调：接收方合约在 onConfidentialTransferReceived 方法中进行加密金额的解密和验证。如果验证通过，更新接收方的余额并返回 true；否则，返回 false 或抛出异常，导致转账失败。

三、Swaps

（一）Swap ERC20 to ConfidentialFungibleToken

下面这段 Solidity 代码展示了一个将普通 ERC20 代币 **“包裹”（wrap）**成保密形式加密代币的过程。它主要做两件事：扣除用户的明文代币，然后 mint（铸造）等量的加密代币。

ERC20 代币仅需直接转入，若转入失败则交易自动回滚。随后，我们通过内部的 _mint 函数转出正确数量的 ConfidentialFungibleToken，该函数保证转出操作必成功。

function wrap(address to, uint256 amount) public virtual {
// take ownership of the tokens
SafeERC20.safeTransferFrom(underlying(), msg.sender, address(this), amount – (amount % rate()));

// mint confidential token
_mint(to, (amount / rate()).toUint64().asEuint64());
}

代码解释

1、函数签名及参数

wrap(address to, uint256 amount)：

to 是接收新铸造的加密代币的地址；

amount 是用户想包裹的明文 ERC20 代币数量。

2、扣除用户明文代币

underlying() 返回被包裹的原始 ERC20 代币合约地址；

safeTransferFrom 从调用者 msg.sender 扣除 (amount – (amount % rate())) 数量的明文代币，转入当前合约；

amount % rate() 残余部分被抹去，确保只扣整倍的代币；

rate() 是一个兑换比例，比如 100:1 ——意味着你需要 100 个明文资产对应 1 个加密代币。

3、铸造对应加密代币

计算铸造数量：amount / rate()，得到你能获取多少单位的加密代币；

toUint64()：确保铸造数量不超过 uint64 的最大值；

.asEuint64()：将普通整数转换为加密整数类型 euint64；

_mint(to, …) 将等量的加密代币（保密状态）铸造/记账给 to 地址。

（二）Swap ConfidentialFungibleToken to ConfidentialFungibleToken

Solidity 代码实现了一个基于 Zama FHE 协议的加密代币交换功能，允许用户在链上进行隐私保护的代币交换。在 Zama 的 FHE 协议中，所有数据都是加密的，只有授权的合约才能解密和操作这些数据。

function swapConfidentialForConfidential(
IConfidentialFungibleToken fromToken,
IConfidentialFungibleToken toToken,
externalEuint64 amountInput,
bytes calldata inputProof
) public virtual {
require(fromToken.isOperator(msg.sender, address(this)));

euint64 amount = FHE.fromExternal(amountInput, inputProof);

FHE.allowTransient(amount, address(fromToken));
euint64 amountTransferred = fromToken.confidentialTransferFrom(msg.sender, address(this), amount);

FHE.allowTransient(amountTransferred, address(toToken));
toToken.confidentialTransfer(msg.sender, amountTransferred);
}

代码解释

①require(fromToken.isOperator(msg.sender, address(this))); 作用：验证调用者（msg.sender）是否被授权为 fromToken 的操作员。

背景：在 Zama 的 FHE 协议中，只有被授权的操作员才能执行加密代币的转账操作。

② euint64 amount = FHE.fromExternal(amountInput, inputProof); 作用：将外部传入的加密数据（amountInput）和证明（inputProof）转换为内部可操作的加密整数类型 euint64。

背景：euint64 是 Zama FHE 协议中用于表示加密整数的类型。

③ FHE.allowTransient(amount, address(fromToken)); 作用：允许对 fromToken 合约地址的临时访问权限，以便执行加密代币的转账操作。

背景：在 FHE 协议中，操作加密数据需要临时授权。

④euint64 amountTransferred = fromToken.confidentialTransferFrom(msg.sender, address(this), amount); 作用：从调用者（msg.sender）向当前合约（address(this)）转移指定数量的加密代币。

背景：confidentialTransferFrom 是 Zama FHE 协议中用于执行加密代币转账的函数。

⑤ FHE.allowTransient(amountTransferred, address(toToken)); 作用：允许对 toToken 合约地址的临时访问权限，以便将转账的加密代币发送给目标地址。

背景：在 FHE 协议中，操作加密数据需要临时授权。

⑥ toToken.confidentialTransfer(msg.sender, amountTransferred); 作用：将转账的加密代币发送到目标地址（msg.sender）。

背景：confidentialTransfer 是 Zama FHE 协议中用于执行加密代币转账的函数。

（三）Swap ConfidentialFungibleToken to ERC20

从保密代币切换到非保密代币是最复杂的操作，因为需要访问解密后的数据才能准确完成请求。在我们的示例中，解密操作将在链下进行，并通过 Zama 的网关将结果回传。以下是一个合约示例，演示如何将保密代币与 ERC20 代币进行 1:1 兑换。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

// 导入 Zama FHE 库，用于处理加密整数类型
import {FHE, externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
// 导入标准 ERC20 接口
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
// 导入 SafeERC20，用于安全转账
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
// 导入保密代币接口
import {IConfidentialFungibleToken} from "@openzeppelin/confidential-contracts/interfaces/IConfidentialFungibleToken.sol";

contract SwapConfidentialToERC20 {
using FHE for *;

// 自定义错误：无效的解密回调请求 ID
error SwapConfidentialToERC20InvalidGatewayRequest(uint256 requestId);

// 映射：存储每个请求 ID 对应的接收者地址
mapping(uint256 => address) private _receivers;

// 保密代币合约（输入端）
IConfidentialFungibleToken private _fromToken;
// 普通 ERC-20 代币合约（输出端）
IERC20 private _toToken;

// 构造函数：初始化输入和输出代币合约地址
constructor(IConfidentialFungibleToken fromToken, IERC20 toToken) {
_fromToken = fromToken;
_toToken = toToken;
}

/**
* @notice 用户调用此函数发起 swap，将加密代币提交；
* @param encryptedInput 加密金额，externalEuint64 类型
* @param inputProof 加密金额的零知识证明
*/
function swapConfidentialToERC20(externalEuint64 encryptedInput, bytes memory inputProof) public {
// 1. 使用 proof 将加密输入转为链上可用的加密整数
euint64 amount = encryptedInput.fromExternal(inputProof);

// 2. 授权保密代币合约读取 this 合约中的这笔加密金额
amount.allowTransient(address(_fromToken));

// 3. 从用户 transfer 保密代币到本合约
euint64 amountTransferred = _fromToken.confidentialTransferFrom(msg.sender, address(this), amount);

// 4. 将 ciphertext 添加到解密请求列表
bytes32 ;
cts[0] = euint64.unwrap(amountTransferred);

// 5. 发出解密请求，并指定回调函数 finalizeSwap
uint256 requestID = FHE.requestDecryption(cts, this.finalizeSwap.selector);

// 6. 保存 requestID ↔ 用户地址 关联，等待回调发币
_receivers[requestID] = msg.sender;
}

/**
* @notice 解密服务调用此函数，将加密金额转成明文后，合约会发放同等 ERC-20 代币
* @param requestID 与 swap 请求对应的唯一 ID
* @param amount 解密后拿到的金额（uint64 明文）
* @param signatures 多重签名验证解密合法性
*/
function finalizeSwap(uint256 requestID, uint64 amount, bytes[] memory signatures) public virtual {
// 1. 验证解密签名是否合法
FHE.checkSignatures(requestID, signatures);

// 2. 获取之前保存的接收方
address to = _receivers[requestID];
if (to == address(0)) revert SwapConfidentialToERC20InvalidGatewayRequest(requestID);

// 3. 清除记录避免重复提现
delete _receivers[requestID];

// 4. 如果解密金额大于 0，将 ERC-20 转给接收者
if (amount != 0) {
SafeERC20.safeTransfer(_toToken, to, amount);
}
}
}

代码解释

注释写在代码上啦。这段 Solidity 合约 SwapConfidentialToERC20 用于将保密代币（encrypted token）兑换成普通 ERC‑20 代币，核心思路是：用户先将加密金额转移到合约，触发链下解密过程，最后由合约释放等值的 ERC‑20。它做了三件事：接收保密代币、提交解密请求、解密成功后，释放相应 ERC‑20 代币。

总结

通过引入操作员机制和带回调的转账函数，智能合约的代币操作变得更加灵活和安全。

操作员机制：用户可以通过 setOperator 方法授权第三方在指定时间内代表自己执行代币操作。这种方式避免了频繁的授权操作，提高了用户体验。

带回调的转账函数：发送方合约在执行代币转账后，自动调用接收方合约的 onConfidentialTransferReceived 方法，实现自动处理。这种方式简化了授权和转账的流程，提高了系统的自动化程度。

通过上述机制的结合，智能合约不仅实现了代币的安全转移，还能够在转账完成后自动触发特定的业务逻辑，为去中心化应用（DApp）提供了更强大的功能支持。