@coti-io/coti-contracts 1.3.0 → 1.3.1

package/contracts/pod/privacy/mocks/MockPodERC20ForPortal.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "../../token/perc20/IPodERC20.sol";
+
+/// @dev Lightweight pToken stand-in for PrivacyPortal unit tests.
+contract MockPodERC20ForPortal {
+    address public lastMintRecipient;
+    uint256 public lastMintAmount;
+    uint256 public lastMintValue;
+    uint256 public lastMintCallbackFee;
+    bytes32 public lastMintRequestId;
+    IPodERC20.RequestStatus private _lastMintStatus;
+
+    address public lastTransferFrom;
+    address public lastTransferTo;
+    uint256 public lastTransferAmount;
+    uint256 public lastTransferValue;
+    uint256 public lastTransferCallbackFee;
+    bytes public lastTransferCallbackData;
+
+    bytes32 public lastTransferRequestId;
+    uint256 public burnedAmount;
+    uint256 public lastBurnValue;
+    uint256 public lastBurnCallbackFee;
+
+    bool public burnShouldRevert;
+    IPodERC20.RequestStatus private _lastTransferStatus;
+
+    mapping(bytes32 => IPodERC20.RequestStatus) private _requestStatus;
+
+    function estimateFee()
+        external
+        pure
+        returns (uint256 totalFeeWei, uint256 targetFeeWei, uint256 callbackFeeWei)
+    {
+        return (1000, 900, 100);
+    }
+
+    function mint(address to, uint256 amount, uint256 callbackFeeLocalWei)
+        external
+        payable
+        returns (bytes32 requestId)
+    {
+        lastMintRecipient = to;
+        lastMintAmount = amount;
+        lastMintValue = msg.value;
+        lastMintCallbackFee = callbackFeeLocalWei;
+        requestId = keccak256(abi.encodePacked("mint", to, amount, block.number));
+        lastMintRequestId = requestId;
+        _lastMintStatus = IPodERC20.RequestStatus.Pending;
+        _requestStatus[requestId] = IPodERC20.RequestStatus.Pending;
+        return requestId;
+    }
+
+    function transferFromAndCallWithPermit(
+        address from,
+        address to,
+        uint256 amount,
+        IPodERC20.PublicPermit calldata,
+        bytes calldata data,
+        uint256 callbackFeeLocalWei
+    ) external payable returns (bytes32 requestId) {
+        lastTransferFrom = from;
+        lastTransferTo = to;
+        lastTransferAmount = amount;
+        lastTransferValue = msg.value;
+        lastTransferCallbackFee = callbackFeeLocalWei;
+        lastTransferCallbackData = data;
+        _lastTransferStatus = IPodERC20.RequestStatus.Pending;
+        requestId = keccak256(abi.encodePacked("transfer", from, to, amount, block.number));
+        lastTransferRequestId = requestId;
+        _requestStatus[requestId] = IPodERC20.RequestStatus.Pending;
+        return requestId;
+    }
+
+    function requests(bytes32 requestId) external view returns (IPodERC20.RequestRecord memory) {
+        IPodERC20.RequestStatus status = _requestStatus[requestId];
+        if (status == IPodERC20.RequestStatus.None) {
+            if (requestId == lastTransferRequestId) {
+                status = _lastTransferStatus;
+            } else if (requestId == lastMintRequestId) {
+                status = _lastMintStatus;
+            }
+        }
+        return IPodERC20.RequestRecord({
+            status: status,
+            recipientLocked: false,
+            account: address(0),
+            spender: address(0)
+        });
+    }
+
+    function balanceOf(address) external pure returns (uint256) {
+        return type(uint256).max;
+    }
+
+    function burn(uint256 amount, uint256 callbackFeeLocalWei) external payable returns (bytes32 requestId) {
+        if (burnShouldRevert) {
+            revert("MockPodERC20ForPortal: burn failed");
+        }
+        burnedAmount += amount;
+        lastBurnValue = msg.value;
+        lastBurnCallbackFee = callbackFeeLocalWei;
+        return keccak256(abi.encodePacked("burn", amount, block.number));
+    }
+
+    function triggerLastTransferCallback() external {
+        require(lastTransferCallbackData.length >= 4, "no callback");
+        (bool ok,) = lastTransferTo.call(lastTransferCallbackData);
+        require(ok, "callback failed");
+    }
+
+    function markLastTransferSuccessful() external {
+        _lastTransferStatus = IPodERC20.RequestStatus.Success;
+        if (lastTransferRequestId != bytes32(0)) {
+            _requestStatus[lastTransferRequestId] = IPodERC20.RequestStatus.Success;
+        }
+    }
+
+    function markLastTransferFailed() external {
+        _lastTransferStatus = IPodERC20.RequestStatus.Failed;
+        if (lastTransferRequestId != bytes32(0)) {
+            _requestStatus[lastTransferRequestId] = IPodERC20.RequestStatus.Failed;
+        }
+    }
+
+    function markLastTransferSystemFailed() external {
+        _lastTransferStatus = IPodERC20.RequestStatus.SystemFailed;
+        if (lastTransferRequestId != bytes32(0)) {
+            _requestStatus[lastTransferRequestId] = IPodERC20.RequestStatus.SystemFailed;
+        }
+    }
+
+    function markLastMintSuccessful() external {
+        _lastMintStatus = IPodERC20.RequestStatus.Success;
+        if (lastMintRequestId != bytes32(0)) {
+            _requestStatus[lastMintRequestId] = IPodERC20.RequestStatus.Success;
+        }
+    }
+
+    function markLastMintFailed() external {
+        _lastMintStatus = IPodERC20.RequestStatus.SystemFailed;
+        if (lastMintRequestId != bytes32(0)) {
+            _requestStatus[lastMintRequestId] = IPodERC20.RequestStatus.SystemFailed;
+        }
+    }
+
+    /// @dev Simulate app `raise` on mint (not refundable via portal).
+    function markLastMintRaised() external {
+        _lastMintStatus = IPodERC20.RequestStatus.Failed;
+        if (lastMintRequestId != bytes32(0)) {
+            _requestStatus[lastMintRequestId] = IPodERC20.RequestStatus.Failed;
+        }
+    }
+
+    function setBurnShouldRevert(bool shouldRevert) external {
+        burnShouldRevert = shouldRevert;
+    }
+}

package/contracts/pod/privacy/mocks/MockPrivacyPortalFactory.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/utils/Pausable.sol";
+
+import "../IPodPriceOracle.sol";
+import "../IPrivacyPortalFactory.sol";
+import "../PrivacyPortalFeeLib.sol";
+
+/// @dev Minimal factory for direct PrivacyPortal unit tests (zero portal fees by default).
+contract MockPrivacyPortalFactory is IPrivacyPortalFactory, Pausable {
+    address public immutable feeRecipient;
+    address public rescueRecipient;
+    address public immutable nativeToken;
+    address public immutable owner_;
+    IPodPriceOracle public priceOracle;
+    bytes32 public defaultDepositFeePacked;
+    bytes32 public defaultWithdrawFeePacked;
+    mapping(address => bool) public blacklisted;
+    mapping(address => bool) public operators;
+
+    constructor(address feeRecipient_, address nativeToken_) {
+        feeRecipient = feeRecipient_;
+        rescueRecipient = feeRecipient_;
+        nativeToken = nativeToken_;
+        owner_ = feeRecipient_;
+        operators[feeRecipient_] = true;
+        defaultDepositFeePacked = PrivacyPortalFeeLib.packFeeConfig(0, 0, type(uint128).max);
+        defaultWithdrawFeePacked = PrivacyPortalFeeLib.packFeeConfig(0, 0, type(uint128).max);
+    }
+
+    function setRescueRecipient(address rescueRecipient_) external {
+        rescueRecipient = rescueRecipient_;
+    }
+
+    function owner() external view returns (address) {
+        return owner_;
+    }
+
+    function isAdmin(address account) external view returns (bool) {
+        return account == owner_;
+    }
+
+    function isOperator(address account) external view returns (bool) {
+        return operators[account];
+    }
+
+    function setOperator(address account, bool allowed) external {
+        operators[account] = allowed;
+    }
+
+    function pause() external {
+        _pause();
+    }
+
+    function unpause() external {
+        _unpause();
+    }
+
+    function depositsPaused() external view returns (bool) {
+        return paused();
+    }
+
+    function withdrawalsPaused() external view returns (bool) {
+        return paused();
+    }
+
+    function setBlacklisted(address account, bool blocked) external {
+        blacklisted[account] = blocked;
+    }
+
+    function setDefaultDepositFee(uint256 fixedFee, uint256 percentageBps, uint256 maxFee) external {
+        defaultDepositFeePacked = PrivacyPortalFeeLib.packFeeConfig(fixedFee, percentageBps, maxFee);
+    }
+
+    function setDefaultWithdrawFee(uint256 fixedFee, uint256 percentageBps, uint256 maxFee) external {
+        defaultWithdrawFeePacked = PrivacyPortalFeeLib.packFeeConfig(fixedFee, percentageBps, maxFee);
+    }
+
+    function estimateDepositPortalFee(address, uint256, uint8)
+        external
+        view
+        returns (uint256 fee, bool usedDynamicPricing)
+    {
+        (uint96 fixedFee,,) = PrivacyPortalFeeLib.unpackFeeConfig(defaultDepositFeePacked);
+        return (fixedFee, false);
+    }
+
+    function estimateWithdrawPortalFee(address, uint256, uint8)
+        external
+        view
+        returns (uint256 fee, bool usedDynamicPricing)
+    {
+        (uint96 fixedFee,,) = PrivacyPortalFeeLib.unpackFeeConfig(defaultWithdrawFeePacked);
+        return (fixedFee, false);
+    }
+
+    function getDepositPortalFeeFloor(address, uint256, uint8)
+        external
+        view
+        returns (uint256 floor, uint128 maxFee)
+    {
+        (uint96 fixedFee,, uint128 max) = PrivacyPortalFeeLib.unpackFeeConfig(defaultDepositFeePacked);
+        return (fixedFee, max);
+    }
+
+    function getWithdrawPortalFeeFloor(address, uint256, uint8)
+        external
+        view
+        returns (uint256 floor, uint128 maxFee)
+    {
+        (uint96 fixedFee,, uint128 max) = PrivacyPortalFeeLib.unpackFeeConfig(defaultWithdrawFeePacked);
+        return (fixedFee, max);
+    }
+
+    function getFeeConfig(bool isDeposit) external view returns (PortalFeeConfig memory config) {
+        return PrivacyPortalFeeLib.decodeFeeConfig(
+            isDeposit ? defaultDepositFeePacked : defaultWithdrawFeePacked
+        );
+    }
+
+    function decodeFeeConfig(bytes32 packed) external pure returns (PortalFeeConfig memory config) {
+        return PrivacyPortalFeeLib.decodeFeeConfig(packed);
+    }
+}

package/contracts/pod/privacy/mocks/MockWrappedNative.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "../../utils/IWrappedNative.sol";
+import "./MockERC20.sol";
+
+/// @dev WETH-like wrapper for native portal tests.
+contract MockWrappedNative is MockERC20, IWrappedNative {
+    constructor(string memory name_, string memory symbol_) MockERC20(name_, symbol_, 18) {}
+
+    receive() external payable {
+        deposit();
+    }
+
+    function deposit() public payable override {
+        _mint(msg.sender, msg.value);
+    }
+
+    function withdraw(uint256 amount) public override {
+        _burn(msg.sender, amount);
+        (bool ok,) = payable(msg.sender).call{value: amount}("");
+        require(ok, "MockWrappedNative: withdraw failed");
+    }
+}

package/contracts/pod/token/erc7984/Erc7984Constants.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/// @title Erc7984Constants
+/// @notice Shared constants for ERC-7984 explorer compatibility.
+library Erc7984Constants {
+    /// @dev Interface id from EIP-7984; Blockscout uses this to classify confidential tokens.
+    bytes4 internal constant INTERFACE_ID = 0x4958f2a4;
+}

package/contracts/pod/token/erc7984/Erc7984Pointers.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/// @title Erc7984Pointers
+/// @notice Maps PoD ciphertext views to ERC-7984 `bytes32` confidential pointers for explorers.
+library Erc7984Pointers {
+    /// @dev Deterministic handle from dual-limb PoD balance/transfer ciphertext. Does not reveal plaintext.
+    function toHandle(ctUint256 memory ct) internal pure returns (bytes32) {
+        return keccak256(abi.encode(ct.ciphertextHigh, ct.ciphertextLow));
+    }
+
+    /// @dev Pick the party-specific amount view for a completed transfer/mint/burn callback.
+    function transferAmountHandle(
+        address from,
+        address to,
+        ctUint256 memory senderValue,
+        ctUint256 memory receiverValue
+    ) internal pure returns (bytes32) {
+        if (from == address(0)) {
+            return toHandle(receiverValue);
+        }
+        if (to == address(0)) {
+            return toHandle(senderValue);
+        }
+        return toHandle(receiverValue);
+    }
+}

package/contracts/pod/token/erc7984/IERC7984.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+/// @title IERC7984
+/// @notice Draft ERC-7984 confidential fungible token interface (pointer-based amounts).
+/// @dev Technology-agnostic EIP-7984 surface for Blockscout and other indexers. PoD pTokens
+///      implement this for explorer compatibility; execution remains async via inbox + COTI.
+interface IERC7984 is IERC165 {
+    /// @dev Emitted when a confidential transfer completes (including mint/burn via zero address).
+    event ConfidentialTransfer(address indexed from, address indexed to, bytes32 indexed amount);
+
+    /// @dev Emitted when an operator authorization is updated.
+    event OperatorSet(address indexed holder, address indexed operator, uint48 until);
+
+    /// @dev Optional: emitted when a pointer amount is publicly disclosed.
+    event AmountDisclosed(bytes32 indexed handle, uint256 amount);
+
+    function name() external view returns (string memory);
+
+    function symbol() external view returns (string memory);
+
+    function decimals() external view returns (uint8);
+
+    function contractURI() external view returns (string memory);
+
+    function confidentialTotalSupply() external view returns (bytes32);
+
+    function confidentialBalanceOf(address account) external view returns (bytes32);
+
+    function isOperator(address holder, address spender) external view returns (bool);
+
+    function setOperator(address operator, uint48 until) external;
+
+    function confidentialTransfer(address to, bytes32 amount) external payable returns (bytes32);
+
+    function confidentialTransfer(address to, bytes32 amount, bytes calldata data) external payable returns (bytes32);
+
+    function confidentialTransferFrom(address from, address to, bytes32 amount) external payable returns (bytes32);
+
+    function confidentialTransferFrom(address from, address to, bytes32 amount, bytes calldata data)
+        external
+        payable
+        returns (bytes32);
+
+    function confidentialTransferAndCall(address to, bytes32 amount, bytes calldata callData)
+        external
+        payable
+        returns (bytes32);
+
+    function confidentialTransferAndCall(address to, bytes32 amount, bytes calldata data, bytes calldata callData)
+        external
+        payable
+        returns (bytes32);
+
+    function confidentialTransferFromAndCall(address from, address to, bytes32 amount, bytes calldata callData)
+        external
+        payable
+        returns (bytes32);
+
+    function confidentialTransferFromAndCall(
+        address from,
+        address to,
+        bytes32 amount,
+        bytes calldata data,
+        bytes calldata callData
+    ) external payable returns (bytes32);
+}

package/contracts/pod/token/erc7984/IERC7984PortalWrapper.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/// @title IERC7984PortalWrapper
+/// @notice Partial ERC-7984 wrapper surface for PrivacyPortal deposit/withdraw explorer visibility.
+/// @dev Does not require full synchronous wrap/unwrap semantics; events mirror OpenZeppelin/Zama naming.
+interface IERC7984PortalWrapper {
+    /// @dev Emitted when underlying is locked and a confidential mint is requested (portal deposit / wrap).
+    event WrapRequested(address indexed from, address indexed to, uint256 amount, bytes32 indexed mintRequestId);
+
+    /// @dev Emitted when a confidential unwrap is requested (portal withdrawal).
+    event UnwrapRequested(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 amount);
+
+    /// @dev Emitted when underlying is released after a confidential unwrap completes.
+    /// @param encryptedAmount PoD portals use `unwrapRequestId` as an explorer correlation id; the
+    ///        real confidential amount pointer is on the pToken `ConfidentialTransfer` in the callback tx.
+    event UnwrapFinalized(
+        address indexed receiver,
+        bytes32 indexed unwrapRequestId,
+        bytes32 encryptedAmount,
+        uint64 cleartextAmount
+    );
+
+    function underlying() external view returns (address);
+
+    /// @dev Conversion rate from underlying to confidential token (1:1 for PoD portals).
+    function rate() external view returns (uint256);
+
+    /// @notice Lock underlying and request async confidential mint (alias for deposit with explicit fee).
+    function wrap(address to, uint256 amount, uint256 mintCallbackFee) external payable returns (bytes32);
+}

package/contracts/pod/token/erc7984/PodErc7984Mixin.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import "../../../utils/mpc/MpcCore.sol";
+import "./Erc7984Constants.sol";
+import "./Erc7984Pointers.sol";
+import "./IERC7984.sol";
+
+/// @title PodErc7984Mixin
+/// @notice ERC-7984 explorer compatibility for PoD pTokens. Emits `ConfidentialTransfer` on async callback success.
+/// @dev Mixed into {PodERC20}. Use native {IPodERC20} async methods for transfers; ERC-7984 transfer entry points revert.
+abstract contract PodErc7984Mixin is IERC7984, ERC165 {
+    /// @notice ERC-7572 metadata URI for explorers (optional).
+    string public contractURI;
+
+    /// @dev Last confidential amount handle emitted on callback; portals may read for unwrap finalization events.
+    bytes32 public lastConfidentialTransferHandle;
+
+    /// @dev ERC-7984 operator approvals (separate from async pToken allowance model).
+    mapping(address => mapping(address => uint48)) private _operatorUntil;
+
+    /// @notice Thrown when an ERC-7984 transfer method is invoked; use {IPodERC20} async entry points instead.
+    error Erc7984UsePodTransferMethods();
+
+    /// @inheritdoc IERC165
+    function supportsInterface(bytes4 interfaceId)
+        public
+        view
+        virtual
+        override(ERC165, IERC165)
+        returns (bool)
+    {
+        return interfaceId == Erc7984Constants.INTERFACE_ID || interfaceId == type(IERC7984).interfaceId
+            || super.supportsInterface(interfaceId);
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTotalSupply() external pure returns (bytes32) {
+        return bytes32(0);
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialBalanceOf(address account) external view returns (bytes32) {
+        return Erc7984Pointers.toHandle(_erc7984BalanceOf(account));
+    }
+
+    /// @inheritdoc IERC7984
+    function isOperator(address holder, address spender) public view returns (bool) {
+        return _operatorUntil[holder][spender] > block.timestamp;
+    }
+
+    /// @inheritdoc IERC7984
+    function setOperator(address operator, uint48 until) external {
+        _operatorUntil[msg.sender][operator] = until;
+        emit OperatorSet(msg.sender, operator, until);
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransfer(address, bytes32) external payable returns (bytes32) {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransfer(address, bytes32, bytes calldata) external payable returns (bytes32) {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransferFrom(address, address, bytes32) external payable returns (bytes32) {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransferFrom(address, address, bytes32, bytes calldata) external payable returns (bytes32) {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransferAndCall(address, bytes32, bytes calldata) external payable returns (bytes32) {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransferAndCall(address, bytes32, bytes calldata, bytes calldata)
+        external
+        payable
+        returns (bytes32)
+    {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransferFromAndCall(address, address, bytes32, bytes calldata)
+        external
+        payable
+        returns (bytes32)
+    {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @inheritdoc IERC7984
+    function confidentialTransferFromAndCall(address, address, bytes32, bytes calldata, bytes calldata)
+        external
+        payable
+        returns (bytes32)
+    {
+        revert Erc7984UsePodTransferMethods();
+    }
+
+    /// @dev Emit ERC-7984 transfer row for explorers after COTI callback applied balances.
+    function _emitConfidentialTransfer(
+        address from,
+        address to,
+        ctUint256 memory senderValue,
+        ctUint256 memory receiverValue
+    ) internal {
+        bytes32 handle = Erc7984Pointers.transferAmountHandle(from, to, senderValue, receiverValue);
+        lastConfidentialTransferHandle = handle;
+        emit ConfidentialTransfer(from, to, handle);
+    }
+
+    /// @dev Child returns cached PoD balance ciphertext for `account`.
+    function _erc7984BalanceOf(address account) internal view virtual returns (ctUint256 memory);
+}

package/contracts/pod/token/erc7984/README.md

@@ -0,0 +1,60 @@
+# ERC-7984 explorer compatibility
+
+PoD pTokens expose a narrow [EIP-7984](https://eips.ethereum.org/EIPS/eip-7984) surface so Blockscout and similar explorers can classify confidential tokens and index completed confidential transfers.
+
+## Contracts
+
+| File | Role |
+|------|------|
+| `IERC7984.sol` | Draft ERC-7984 interface (`bytes32` confidential pointers) |
+| `IERC7984PortalWrapper.sol` | Partial wrapper events/views for `PrivacyPortal` |
+| `Erc7984Constants.sol` | Interface id `0x4958f2a4` |
+| `Erc7984Pointers.sol` | Maps PoD `ctUint256` to explorer handles |
+| `PodErc7984Mixin.sol` | ERC-165 + metadata + `ConfidentialTransfer` emission |
+
+`PodERC20` inherits `PodErc7984Mixin` and emits `ConfidentialTransfer` alongside the existing `Transfer` event when COTI callbacks succeed.
+
+`PrivacyPortal` emits `WrapRequested` on deposit/wrap and `UnwrapRequested` / `UnwrapFinalized` on withdraw/release.
+
+## Important notes
+
+- This is **explorer compatibility**, not Zama FHE semantic equivalence.
+- ERC-7984 transfer entry points revert with `Erc7984UsePodTransferMethods`; use native async `IPodERC20` methods for actual moves.
+- Explorer-visible confidential transfers are emitted **only after async callback success** on production `PodERC20`.
+- **Live Sepolia pMTT/pWETH/pUSDC deployments do not include this mixin yet** — they emit `Transfer` only until upgraded. Use `DummyTestPERC20` at fresh addresses for explorer testing without touching production contracts.
+
+## Dummy test stack (no COTI)
+
+| File | Role |
+|------|------|
+| `contracts/mocks/DummyTestPERC20.sol` | Synchronous test pToken with `ConfidentialTransfer` on every completed move |
+| `contracts/mocks/PodCallbackTestInbox.sol` | Optional inbox stub to complete pending dummy mints/transfers |
+
+Deploy and run on Sepolia (new addresses each run; saves `erc7984-dummy-deploy.json`):
+
+```bash
+npm run demo:erc7984-dummy-sepolia
+```
+
+Then verify the pToken on Blockscout Sepolia so `supportsInterface(0x4958f2a4)` and `ConfidentialTransfer` appear in the UI.
+
+## Tests
+
+```bash
+npm run test:erc7984
+```
+
+Blockscout verification (requires deployed verified contracts):
+
+```bash
+ERC7984_EXPLORER_TESTS=1 \
+ERC7984_PTOKEN=0x... \
+ERC7984_BLOCKSCOUT_API=https://eth.blockscout.com/api/v2 \
+npm run test:erc7984-explorer
+```
+
+Optional tx inspection:
+
+```bash
+npx tsx scripts/erc7984/check-blockscout.ts --token 0x... --tx 0x...
+```