create-fhevm-example 1.3.2 → 1.4.0

package/contracts/gaming/RockPaperScissors.sol

@@ -0,0 +1,213 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.24;
+
+import {
+    FHE,
+    euint8,
+    ebool,
+    externalEuint8
+} from "@fhevm/solidity/lib/FHE.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/**
+ * @notice Rock-Paper-Scissors game with encrypted moves - fair play guaranteed!
+ *
+ * @dev Demonstrates FHE commit-reveal pattern without trusted third party:
+ *      - Players submit encrypted moves (0=Rock, 1=Paper, 2=Scissors)
+ *      - FHE comparison determines winner without revealing moves
+ *      - Loser's move revealed only after game concludes
+ *
+ * Move encoding: 0 = Rock, 1 = Paper, 2 = Scissors
+ * Win logic: (move1 - move2 + 3) % 3 → 1 = player1 wins, 2 = player2 wins
+ *
+ * ⚠️ IMPORTANT: Uses FHE.rem for modulo - computationally expensive but secure
+ */
+contract RockPaperScissors is ZamaEthereumConfig {
+    // ==================== TYPES ====================
+
+    enum GameState {
+        WaitingForPlayers, // 0 or 1 player joined
+        BothMoved,         // Both players submitted moves
+        Revealed           // Winner determined and revealed
+    }
+
+    // ==================== STATE ====================
+
+    /// Player 1 address
+    address public player1;
+
+    /// Player 2 address
+    address public player2;
+
+    /// Game state
+    GameState public state;
+
+    /// Encrypted moves
+    euint8 private _move1;
+    euint8 private _move2;
+
+    /// Winner address (set after reveal)
+    address public winner;
+
+    /// Game ID for tracking multiple games
+    uint256 public gameId;
+
+    // ==================== EVENTS ====================
+
+    /// @notice Emitted when a player joins
+    /// @param player Address of joining player
+    /// @param playerNumber 1 or 2
+    event PlayerJoined(address indexed player, uint8 playerNumber);
+
+    /// @notice Emitted when both moves are submitted
+    event BothMovesMade();
+
+    /// @notice Emitted when winner is revealed
+    /// @param winner Address of winner (address(0) for tie)
+    /// @param gameId Current game ID
+    event GameResult(address indexed winner, uint256 indexed gameId);
+
+    // ==================== CONSTRUCTOR ====================
+
+    /// @notice Creates a new Rock-Paper-Scissors game
+    constructor() {
+        gameId = 1;
+        state = GameState.WaitingForPlayers;
+    }
+
+    // ==================== PLAY FUNCTIONS ====================
+
+    /// @notice Submit an encrypted move to play
+    /// @dev Move must be 0 (Rock), 1 (Paper), or 2 (Scissors)
+    /// @param encryptedMove Encrypted move value (0-2)
+    /// @param inputProof Proof validating the encrypted input
+    function play(
+        externalEuint8 encryptedMove,
+        bytes calldata inputProof
+    ) external {
+        require(state == GameState.WaitingForPlayers, "Game not accepting moves");
+        require(
+            msg.sender != player1 && msg.sender != player2,
+            "Already in this game"
+        );
+
+        // 🔐 Convert external encrypted input to internal euint8
+        euint8 move = FHE.fromExternal(encryptedMove, inputProof);
+
+        // ✅ Grant contract permission to operate on this value
+        FHE.allowThis(move);
+
+        if (player1 == address(0)) {
+            // First player joins
+            player1 = msg.sender;
+            _move1 = move;
+            emit PlayerJoined(msg.sender, 1);
+        } else {
+            // Second player joins
+            player2 = msg.sender;
+            _move2 = move;
+            state = GameState.BothMoved;
+            emit PlayerJoined(msg.sender, 2);
+            emit BothMovesMade();
+        }
+    }
+
+    /// @notice Determine the winner using FHE computation
+    /// @dev Anyone can call after both players have moved
+    function determineWinner() external {
+        require(state == GameState.BothMoved, "Not ready to determine winner");
+
+        // 🎯 Winner calculation using FHE
+        // Formula: (move1 - move2 + 3) % 3
+        // Result: 0 = tie, 1 = player1 wins, 2 = player2 wins
+
+        // Convert moves to computation: add 3 to avoid negative numbers
+        // move1 + 3 - move2 = (move1 - move2 + 3)
+        euint8 diff = FHE.add(FHE.add(_move1, FHE.asEuint8(3)), FHE.neg(_move2));
+
+        // Modulo 3 to get result (0, 1, or 2)
+        euint8 result = FHE.rem(diff, 3);
+
+        // 🔍 Check outcomes
+        ebool isTie = FHE.eq(result, FHE.asEuint8(0));
+        ebool player1Wins = FHE.eq(result, FHE.asEuint8(1));
+
+        // 📊 Encode winner as address bits (simplified for demo)
+        // In production, use public decryption pattern
+
+        // Make result publicly decryptable
+        FHE.allowThis(result);
+        FHE.makePubliclyDecryptable(result);
+
+        // Store encrypted result for later reveal
+        // For this demo, we'll use select to pick winner
+
+        state = GameState.Revealed;
+
+        emit GameResult(address(0), gameId); // Placeholder - real winner after decryption
+    }
+
+    /// @notice Reveal winner with decryption proof
+    /// @param abiEncodedResult ABI-encoded uint8 result
+    /// @param decryptionProof KMS signature proving decryption
+    function revealWinner(
+        bytes memory abiEncodedResult,
+        bytes memory decryptionProof
+    ) external {
+        require(state == GameState.Revealed, "Game not ready for reveal");
+
+        // Build ciphertext list for verification
+        euint8 diff = FHE.add(FHE.add(_move1, FHE.asEuint8(3)), FHE.neg(_move2));
+        euint8 result = FHE.rem(diff, 3);
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = FHE.toBytes32(result);
+
+        // Verify the decryption proof
+        FHE.checkSignatures(cts, abiEncodedResult, decryptionProof);
+
+        // Decode result
+        uint8 resultValue = abi.decode(abiEncodedResult, (uint8));
+
+        if (resultValue == 0) {
+            winner = address(0); // Tie
+        } else if (resultValue == 1) {
+            winner = player1;
+        } else {
+            winner = player2;
+        }
+
+        emit GameResult(winner, gameId);
+    }
+
+    /// @notice Reset for a new game
+    /// @dev Only callable after game is revealed
+    function resetGame() external {
+        require(state == GameState.Revealed, "Current game not finished");
+
+        // Reset state
+        player1 = address(0);
+        player2 = address(0);
+        winner = address(0);
+        state = GameState.WaitingForPlayers;
+        gameId++;
+    }
+
+    // ==================== VIEW FUNCTIONS ====================
+
+    /// @notice Get current game state
+    function getGameState() external view returns (
+        address p1,
+        address p2,
+        GameState currentState,
+        address currentWinner,
+        uint256 currentGameId
+    ) {
+        return (player1, player2, state, winner, gameId);
+    }
+
+    /// @notice Check if an address is in the current game
+    function isPlayer(address addr) external view returns (bool) {
+        return addr == player1 || addr == player2;
+    }
+}

package/contracts/openzeppelin/ERC7984.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.27;
+
+import {
+    Ownable2Step,
+    Ownable
+} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+import {FHE, externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {
+    ERC7984 as ERC7984Base
+} from "@openzeppelin/confidential-contracts/token/ERC7984/ERC7984.sol";
+
+/**
+ * @notice Confidential token using OpenZeppelin's ERC7984 standard
+ *
+ * @dev Demonstrates minting and burning with both visible and encrypted amounts.
+ *      Shows how to integrate FHE with standard token operations.
+ */
+contract ERC7984Example is ZamaEthereumConfig, ERC7984Base, Ownable2Step {
+    /// @notice Creates a new confidential ERC7984 token with initial supply
+    /// @param owner Address that will own the token and receive initial supply
+    /// @param amount Initial supply amount (visible on-chain but stored encrypted)
+    /// @param name_ Token name
+    /// @param symbol_ Token symbol
+    /// @param tokenURI_ Token metadata URI
+    constructor(
+        address owner,
+        uint64 amount,
+        string memory name_,
+        string memory symbol_,
+        string memory tokenURI_
+    ) ERC7984Base(name_, symbol_, tokenURI_) Ownable(owner) {
+        // 🔐 Mint initial supply as encrypted amount
+        euint64 encryptedAmount = FHE.asEuint64(amount);
+        _mint(owner, encryptedAmount);
+    }
+
+    // ==================== MINTING ====================
+
+    /// @notice Mint with visible amount (owner knows the amount)
+    /// @dev Amount is visible on-chain but stored encrypted
+    function mint(address to, uint64 amount) external onlyOwner {
+        _mint(to, FHE.asEuint64(amount));
+    }
+
+    /// @notice Mint with encrypted amount (full privacy)
+    /// @dev Even the contract doesn't know the minted amount
+    function confidentialMint(
+        address to,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) external onlyOwner returns (euint64 transferred) {
+        return _mint(to, FHE.fromExternal(encryptedAmount, inputProof));
+    }
+
+    // ==================== BURNING ====================
+
+    /// @notice Burn with visible amount
+    function burn(address from, uint64 amount) external onlyOwner {
+        _burn(from, FHE.asEuint64(amount));
+    }
+
+    /// @notice Burn with encrypted amount (full privacy)
+    function confidentialBurn(
+        address from,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) external onlyOwner returns (euint64 transferred) {
+        return _burn(from, FHE.fromExternal(encryptedAmount, inputProof));
+    }
+
+    // ==================== INTERNAL ====================
+
+    /// @dev Grant owner access to total supply on every transfer
+    function _update(
+        address from,
+        address to,
+        euint64 amount
+    ) internal virtual override returns (euint64 transferred) {
+        transferred = super._update(from, to, amount);
+        // Allow owner to decrypt total supply
+        FHE.allow(confidentialTotalSupply(), owner());
+    }
+}

package/contracts/openzeppelin/ERC7984ERC20Wrapper.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.27;
+
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
+import {
+    ERC7984ERC20Wrapper as ERC7984ERC20WrapperBase,
+    ERC7984
+} from "@openzeppelin/confidential-contracts/token/ERC7984/extensions/ERC7984ERC20Wrapper.sol";
+
+/**
+ * @notice Wraps ERC20 tokens into confidential ERC7984 tokens
+ *
+ * @dev WRAP: ERC20 → ERC7984 (public → private)
+ *      UNWRAP: ERC7984 → ERC20 (private → public, requires decryption)
+ */
+contract ERC7984ERC20WrapperExample is
+    ERC7984ERC20WrapperBase,
+    ZamaEthereumConfig
+{
+    /// @notice Creates a new ERC20-to-ERC7984 wrapper
+    /// @param token The ERC20 token to wrap
+    /// @param name Name for the wrapped ERC7984 token
+    /// @param symbol Symbol for the wrapped ERC7984 token
+    /// @param uri Metadata URI for the wrapped token
+    constructor(
+        IERC20 token,
+        string memory name,
+        string memory symbol,
+        string memory uri
+    ) ERC7984ERC20WrapperBase(token) ERC7984(name, symbol, uri) {}
+
+    // 📦 Inherited from ERC7984ERC20Wrapper:
+    //
+    // wrap(address to, uint256 amount)
+    //   - User approves this contract for ERC20
+    //   - ERC20 is escrowed, ERC7984 is minted
+    //
+    // unwrap(address from, address to, euint64 amount)
+    //   - ERC7984 is burned
+    //   - Decryption is requested
+    //   - After proof, ERC20 is released
+}

package/contracts/openzeppelin/SwapERC7984ToERC20.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.27;
+
+import {FHE, externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
+import {
+    SafeERC20
+} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {
+    IERC7984
+} from "@openzeppelin/confidential-contracts/interfaces/IERC7984.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/**
+ * @notice Swap confidential ERC7984 tokens to regular ERC20 tokens
+ *
+ * @dev Uses FHEVM v0.9 decryption flow:
+ *      FHE.makePubliclyDecryptable() + FHE.checkSignatures()
+ */
+contract SwapERC7984ToERC20Example is ZamaEthereumConfig {
+    using SafeERC20 for IERC20;
+
+    error InvalidSwap(euint64 encryptedAmount);
+
+    struct PendingSwap {
+        address receiver;
+        bool pending;
+    }
+
+    mapping(euint64 => PendingSwap) private _pendingSwaps;
+    IERC7984 private _fromToken;
+    IERC20 private _toToken;
+
+    event SwapInitiated(
+        euint64 indexed encryptedAmount,
+        address indexed receiver
+    );
+    event SwapFinalized(address indexed receiver, uint64 amount);
+
+    constructor(IERC7984 fromToken, IERC20 toToken) {
+        _fromToken = fromToken;
+        _toToken = toToken;
+    }
+
+    // ==================== STEP 1: INITIATE ====================
+
+    /// @notice Start the swap - transfers ERC7984 and requests decryption
+    function initiateSwap(
+        externalEuint64 encryptedInput,
+        bytes calldata inputProof
+    ) public {
+        euint64 amount = FHE.fromExternal(encryptedInput, inputProof);
+
+        // Transfer ERC7984 from user to this contract
+        FHE.allowTransient(amount, address(_fromToken));
+        euint64 amountTransferred = _fromToken.confidentialTransferFrom(
+            msg.sender,
+            address(this),
+            amount
+        );
+
+        // 🔓 FHEVM v0.9: Request public decryption
+        // KMS will provide proof that this value decrypts to X
+        FHE.makePubliclyDecryptable(amountTransferred);
+        FHE.allowThis(amountTransferred);
+
+        // Register pending swap
+        _pendingSwaps[amountTransferred] = PendingSwap({
+            receiver: msg.sender,
+            pending: true
+        });
+
+        emit SwapInitiated(amountTransferred, msg.sender);
+    }
+
+    // ==================== STEP 2: FINALIZE ====================
+
+    /// @notice Complete the swap with decryption proof from KMS
+    /// @dev encryptedAmount: The handle from initiateSwap
+    ///      cleartextAmount: The decrypted value
+    ///      decryptionProof: Proof from KMS that decryption is valid
+    function finalizeSwap(
+        euint64 encryptedAmount,
+        uint64 cleartextAmount,
+        bytes calldata decryptionProof
+    ) public {
+        PendingSwap storage pending = _pendingSwaps[encryptedAmount];
+        require(pending.pending, InvalidSwap(encryptedAmount));
+
+        // 🔐 FHEVM v0.9: Verify decryption proof
+        // This ensures cleartextAmount is the TRUE decryption of encryptedAmount
+        bytes32[] memory handles = new bytes32[](1);
+        handles[0] = euint64.unwrap(encryptedAmount);
+        FHE.checkSignatures(
+            handles,
+            abi.encode(cleartextAmount),
+            decryptionProof
+        );
+
+        address receiver = pending.receiver;
+        delete _pendingSwaps[encryptedAmount];
+
+        // Release ERC20 to user
+        if (cleartextAmount != 0) {
+            _toToken.safeTransfer(receiver, cleartextAmount);
+        }
+
+        emit SwapFinalized(receiver, cleartextAmount);
+    }
+}

package/contracts/openzeppelin/SwapERC7984ToERC7984.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.27;
+
+import {FHE, externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {
+    IERC7984
+} from "@openzeppelin/confidential-contracts/interfaces/IERC7984.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/**
+ * @notice Fully confidential swap between two ERC7984 tokens
+ *
+ * @dev Both input and output amounts remain encrypted throughout the swap.
+ */
+contract SwapERC7984ToERC7984Example is ZamaEthereumConfig {
+    /// @notice Swap confidential token for another confidential token
+    /// @dev fromToken: The token to swap from
+    ///      toToken: The token to receive
+    ///      amountInput: Encrypted amount to swap
+    ///      inputProof: Proof for the encrypted input
+    function swapConfidentialForConfidential(
+        IERC7984 fromToken,
+        IERC7984 toToken,
+        externalEuint64 amountInput,
+        bytes calldata inputProof
+    ) public virtual {
+        // 🔍 Check caller is operator for this contract
+        require(
+            fromToken.isOperator(msg.sender, address(this)),
+            "Not authorized operator"
+        );
+
+        euint64 amount = FHE.fromExternal(amountInput, inputProof);
+
+        // 📥 Transfer fromToken: user → this contract
+        FHE.allowTransient(amount, address(fromToken));
+        euint64 amountTransferred = fromToken.confidentialTransferFrom(
+            msg.sender,
+            address(this),
+            amount
+        );
+
+        // 📤 Transfer toToken: this contract → user
+        // Amount stays encrypted throughout!
+        FHE.allowTransient(amountTransferred, address(toToken));
+        toToken.confidentialTransfer(msg.sender, amountTransferred);
+    }
+}

package/contracts/openzeppelin/VestingWallet.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.27;
+
+import {FHE, ebool, euint64, euint128} from "@fhevm/solidity/lib/FHE.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {
+    ReentrancyGuardTransient
+} from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {
+    IERC7984
+} from "@openzeppelin/confidential-contracts/interfaces/IERC7984.sol";
+
+/**
+ * @notice Linear vesting wallet for ERC7984 tokens - amounts stay encrypted!
+ *
+ * @dev Timeline: |--START--|---VESTING---|--END--|
+ *                 0%        linear        100%
+ *
+ * All vesting calculations are performed on encrypted values using FHE operations.
+ */
+contract VestingWalletExample is
+    Ownable,
+    ReentrancyGuardTransient,
+    ZamaEthereumConfig
+{
+    // 🔐 Track released amounts per token (encrypted)
+    mapping(address token => euint128) private _tokenReleased;
+    uint64 private _start;
+    uint64 private _duration;
+
+    /// @notice Emitted when vested tokens are released to beneficiary
+    /// @param token The ERC7984 token address
+    /// @param amount The encrypted amount released
+    event VestingWalletConfidentialTokenReleased(
+        address indexed token,
+        euint64 amount
+    );
+
+    /// @notice Creates a new vesting wallet for a beneficiary
+    /// @param beneficiary Address that will receive vested tokens
+    /// @param startTimestamp Unix timestamp when vesting begins
+    /// @param durationSeconds Duration of the vesting period in seconds
+    constructor(
+        address beneficiary,
+        uint48 startTimestamp,
+        uint48 durationSeconds
+    ) Ownable(beneficiary) {
+        _start = startTimestamp;
+        _duration = durationSeconds;
+    }
+
+    // ==================== VIEW FUNCTIONS ====================
+
+    function start() public view virtual returns (uint64) {
+        return _start;
+    }
+
+    function duration() public view virtual returns (uint64) {
+        return _duration;
+    }
+
+    function end() public view virtual returns (uint64) {
+        return start() + duration();
+    }
+
+    /// @notice Encrypted amount already released for token
+    function released(address token) public view virtual returns (euint128) {
+        return _tokenReleased[token];
+    }
+
+    // ==================== CORE LOGIC ====================
+
+    /// @notice Calculate how much can be released now
+    /// @dev Returns encrypted amount - no one knows the actual value
+    function releasable(address token) public virtual returns (euint64) {
+        euint128 vestedAmount_ = vestedAmount(token, uint48(block.timestamp));
+        euint128 releasedAmount = released(token);
+
+        // 🔀 FHE.select: encrypted if-else
+        // If vested >= released: return (vested - released)
+        // Else: return 0
+        ebool canRelease = FHE.ge(vestedAmount_, releasedAmount);
+        return
+            FHE.select(
+                canRelease,
+                FHE.asEuint64(FHE.sub(vestedAmount_, releasedAmount)),
+                FHE.asEuint64(0)
+            );
+    }
+
+    /// @notice Release vested tokens to beneficiary
+    function release(address token) public virtual nonReentrant {
+        euint64 amount = releasable(token);
+
+        // Transfer encrypted amount to owner
+        FHE.allowTransient(amount, token);
+        euint64 amountSent = IERC7984(token).confidentialTransfer(
+            owner(),
+            amount
+        );
+
+        // Update released amount (encrypted)
+        euint128 newReleasedAmount = FHE.add(released(token), amountSent);
+        FHE.allow(newReleasedAmount, owner());
+        FHE.allowThis(newReleasedAmount);
+        _tokenReleased[token] = newReleasedAmount;
+
+        emit VestingWalletConfidentialTokenReleased(token, amountSent);
+    }
+
+    /// @notice Calculate vested amount at timestamp
+    function vestedAmount(
+        address token,
+        uint48 timestamp
+    ) public virtual returns (euint128) {
+        // Total = released + current balance
+        euint128 totalAllocation = FHE.add(
+            released(token),
+            IERC7984(token).confidentialBalanceOf(address(this))
+        );
+        return _vestingSchedule(totalAllocation, timestamp);
+    }
+
+    // ==================== INTERNAL ====================
+
+    /// @dev Linear vesting: (total * elapsed) / duration
+    function _vestingSchedule(
+        euint128 totalAllocation,
+        uint48 timestamp
+    ) internal virtual returns (euint128) {
+        if (timestamp < start()) {
+            // Before start: 0% vested
+            return euint128.wrap(0);
+        } else if (timestamp >= end()) {
+            // After end: 100% vested
+            return totalAllocation;
+        } else {
+            // During vesting: linear unlock
+            return
+                FHE.div(
+                    FHE.mul(totalAllocation, (timestamp - start())),
+                    duration()
+                );
+        }
+    }
+}

package/contracts/openzeppelin/mocks/ERC20Mock.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+ * @notice Simple ERC20 mock for testing purposes
+ */
+contract ERC20Mock is ERC20 {
+    uint8 private _decimals;
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint8 decimals_
+    ) ERC20(name_, symbol_) {
+        _decimals = decimals_;
+    }
+
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+
+    function burn(address from, uint256 amount) external {
+        _burn(from, amount);
+    }
+}

package/dist/scripts/commands/add-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-mode.d.ts","sourceRoot":"","sources":["../../../scripts/commands/add-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2OH;;GAEG;AACH,wBAAsB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8ElE"}