{"status":"1","message":"","result":{"address":"0x7AF89556A11FCfE6cF1c3e3D1c36AfBcee2f0073","balance":"8000000000000000","nonce":"1","codeHash":"0xa91afc0992ed3062e0bd700d5ebc1f7824d27980d4e36e64498a6f59cc0a1c20","stakingBalance":"0","collateralForStorage":"0","accumulatedInterestReturn":"0","admin":"0x0000000000000000000000000000000000000000","cfxTransferTab":1,"erc20TransferTab":0,"erc721TransferTab":0,"erc1155TransferTab":0,"nftAssetTab":0,"minedBlockTab":0,"authorizationsTab":0,"sponsor":{"sponsorForGas":"0x0000000000000000000000000000000000000000","sponsorForCollateral":"0x0000000000000000000000000000000000000000","sponsorGasBound":"0","sponsorBalanceForGas":"0","sponsorBalanceForCollateral":"0","availableStoragePoints":null,"usedStoragePoints":null},"epochNumber":33222180,"transactionHash":"0xb145199f95db9b6bef5988ad56c5535b30fe4a4e2d3e3aeb1ba60f12de88e614","from":"0xD24e06f0DBadA268314DbcB97F48f87b85b6Dd30","contractFactory":"","timestamp":1778759130,"hex40id":213993,"name":null,"website":null,"abi":"[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"brain_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"name\":\"InsufficientValue\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"LengthMismatch\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"TransferFailed\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"ZeroAddress\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"ZeroAmount\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"Distributed\",\"type\":\"event\",\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"brainOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"payer\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"reason\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"name\":\"WithdrawnByOwner\",\"type\":\"event\",\"inputs\":[{\"name\":\"brainOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"name\":\"BRAIN\",\"type\":\"function\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contract IERC721Owner\"}],\"stateMutability\":\"view\"},{\"name\":\"distribute\",\"type\":\"function\",\"inputs\":[{\"name\":\"tokenIds\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"amounts\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"reason\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"name\":\"pendingWithdrawals\",\"type\":\"function\",\"inputs\":[{\"name\":\"brainOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"name\":\"withdraw\",\"type\":\"function\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"}]","sourceCode":"{\"sources\":{\"src/lib/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.30;\\n\\n// forgefmt: disable-start\\n//\\n//        ██████╗ ██████╗  █████╗ ██╗███╗   ██╗██████╗ ███████╗██████╗ ██╗ █████╗\\n//        ██╔══██╗██╔══██╗██╔══██╗██║████╗  ██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗\\n//        ██████╔╝██████╔╝███████║██║██╔██╗ ██║██████╔╝█████╗  ██║  ██║██║███████║\\n//        ██╔══██╗██╔══██╗██╔══██║██║██║╚██╗██║██╔═══╝ ██╔══╝  ██║  ██║██║██╔══██║\\n//        ██████╔╝██║  ██║██║  ██║██║██║ ╚████║██║     ███████╗██████╔╝██║██║  ██║\\n//        ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═╝     ╚══════╝╚═════╝ ╚═╝╚═╝  ╚═╝\\n//\\n//        Specialty AI Brains as iNFTs · Agent-paid knowledge marketplace\\n//\\n// forgefmt: disable-end\\n\\n/// @title  Errors\\n/// @author Brainpedia Team\\n/// @notice Custom errors used across the Brainpedia contract suite.\\n/// @dev    Library of error declarations. Replaces every `require(cond, \\\"string\\\")`\\n///         in Brain, BrainOracle, BrainMinter, RoyaltyDistributor, SubnameRegistrar,\\n///         and AccessTokenRegistrar. Custom errors are gas-efficient and fully\\n///         typed for off-chain decoding.\\nlibrary Errors {\\n    // ----- Generic input validation -----\\n\\n    /// @notice Thrown when an address parameter is the zero address.\\n    error ZeroAddress();\\n\\n    /// @notice Thrown when an amount parameter is zero.\\n    error ZeroAmount();\\n\\n    /// @notice Thrown when two arrays that must be the same length are not.\\n    error LengthMismatch();\\n\\n    /// @notice Thrown when a native ETH transfer fails.\\n    error EthTransferFailed();\\n\\n    /// @notice Thrown when ECDSA recovery does not return the configured signer.\\n    error InvalidSignature();\\n\\n    // ----- Brain (ERC-7857 iNFT) -----\\n\\n    /// @notice Thrown when `msg.sender` is not the owner of the targeted tokenId.\\n    error NotBrainOwner();\\n\\n    /// @notice Thrown when authorizeUsage is called with msg.value below the\\n    ///         Brain's configured per-query minimum payment.\\n    error InsufficientPayment();\\n\\n    /// @notice Thrown when the per-query payment forward from the Brain contract\\n    ///         to the Brain owner fails (e.g., recipient is a contract that reverts\\n    ///         on receive).\\n    error PaymentForwardFailed();\\n\\n    /// @notice Thrown when a view function is called on a tokenId that has no\\n    ///         IntelligentData records yet (i.e., was never minted or was burned).\\n    error NoIntelligence();\\n\\n    // ----- ERC-7857 canonical transfer path -----\\n\\n    /// @notice Thrown when a caller invokes `transferFrom` or `safeTransferFrom`\\n    ///         directly. ERC-7857 mandates the oracle-attested `secureTransfer`\\n    ///         path so that the per-Brain symmetric key can be re-sealed for the\\n    ///         new owner. Standard ERC-721 transfers would leave the recipient\\n    ///         with an undecryptable Brain.\\n    error UseSecureTransfer();\\n\\n    /// @notice Thrown when secureTransfer is called before an oracle is set.\\n    error OracleNotSet();\\n\\n    /// @notice Thrown when the configured oracle rejects the supplied proof.\\n    error InvalidOracleProof();\\n\\n    // ----- BrainOracle attestation -----\\n\\n    /// @notice Thrown when verifyProof is called while the attestor is unset.\\n    error AttestorNotSet();\\n\\n    /// @notice Thrown when the EIP-712 TransferAttestation deadline has passed.\\n    error AttestationExpired();\\n\\n    /// @notice Thrown when the supplied oracle proof is malformed (e.g., too\\n    ///         short to ABI-decode as a TransferAttestation).\\n    error InvalidProofFormat();\\n\\n    // ----- BrainMinter anti-spam -----\\n\\n    /// @notice Thrown when mintToSender is called with msg.value below the\\n    ///         currently-configured anti-spam mint fee.\\n    error InsufficientFee();\\n\\n    /// @notice Thrown when an internal native-token transfer fails (fee sweep,\\n    ///         payment forward, refund).\\n    error TransferFailed();\\n\\n    // ----- RoyaltyDistributor -----\\n\\n    /// @notice Thrown when distribute() is called with msg.value below the\\n    ///         sum of per-Brain payment amounts.\\n    error InsufficientValue();\\n\\n    // ----- ENS subname + access-token registrars -----\\n\\n    /// @notice Thrown when a registrar tries to issue a subname whose label\\n    ///         hash is already registered.\\n    error LabelAlreadyTaken();\\n\\n    /// @notice Thrown when a subname text-record write is attempted by an\\n    ///         account that does not own the label.\\n    error NotLabelOwner();\\n\\n    /// @notice Thrown when a non-issuer account calls a function gated by\\n    ///         the issuer allow-list on AccessTokenRegistrar.\\n    error NotIssuer();\\n\\n    /// @notice Thrown when an AccessTokenRegistrar operation references a\\n    ///         label that has never been issued.\\n    error TokenNotFound();\\n\\n    /// @notice Thrown when an AccessTokenRegistrar operation references a\\n    ///         label whose TTL has elapsed.\\n    error TokenExpired();\\n}\\n\"},\"src/RoyaltyDistributor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.30;\\n\\n// forgefmt: disable-start\\n//\\n//        ██████╗ ██████╗  █████╗ ██╗███╗   ██╗██████╗ ███████╗██████╗ ██╗ █████╗\\n//        ██╔══██╗██╔══██╗██╔══██╗██║████╗  ██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗\\n//        ██████╔╝██████╔╝███████║██║██╔██╗ ██║██████╔╝█████╗  ██║  ██║██║███████║\\n//        ██╔══██╗██╔══██╗██╔══██║██║██║╚██╗██║██╔═══╝ ██╔══╝  ██║  ██║██║██╔══██║\\n//        ██████╔╝██║  ██║██║  ██║██║██║ ╚████║██║     ███████╗██████╔╝██║██║  ██║\\n//        ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═╝     ╚══════╝╚═════╝ ╚═╝╚═╝  ╚═╝\\n//\\n//        Specialty AI Brains as iNFTs · Agent-paid knowledge marketplace\\n//\\n// forgefmt: disable-end\\n\\nimport { ReentrancyGuard } from \\\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\\\";\\n\\nimport { Errors } from \\\"./lib/Errors.sol\\\";\\n\\ninterface IERC721Owner {\\n    function ownerOf(uint256 tokenId) external view returns (address);\\n}\\n\\n/// @title  RoyaltyDistributor\\n/// @author Brainpedia Team\\n/// @notice Settles a multi-Brain query payment in a single transaction.\\n///         Takes a list of (tokenId, amount) pairs and credits each amount\\n///         to the corresponding Brain owner's pending balance for later\\n///         pull-collection.\\n/// @dev    Audit finding #3: pull-payment pattern prevents a reverting Brain\\n///         owner from DoS-ing the entire batch. Each (tokenId, amount) pair\\n///         increments `pendingWithdrawals[ownerOf(tokenId)]`. Brain owners\\n///         call `withdraw()` to collect. Surplus `msg.value` is refunded to\\n///         the caller at the end of `distribute`.\\ncontract RoyaltyDistributor is ReentrancyGuard {\\n    // ============ Immutables ============\\n\\n    IERC721Owner public immutable BRAIN;\\n\\n    // ============ Storage ============\\n\\n    /// @notice Brain owner → pending native payment balance (wei).\\n    mapping(address brainOwner => uint256 amount) public pendingWithdrawals;\\n\\n    // ============ Events ============\\n\\n    /// @notice Per-recipient distribution log.\\n    event Distributed(\\n        uint256 indexed tokenId,\\n        address indexed brainOwner,\\n        address indexed payer,\\n        uint256 amount,\\n        bytes32 reason\\n    );\\n    event WithdrawnByOwner(address indexed brainOwner, uint256 amount);\\n\\n    // ============ Constructor ============\\n\\n    constructor(address brain_) {\\n        if (brain_ == address(0)) revert Errors.ZeroAddress();\\n        BRAIN = IERC721Owner(brain_);\\n    }\\n\\n    // ============ External: distribute ============\\n\\n    /// @param tokenIds the Brain iNFTs to pay\\n    /// @param amounts  amount-in-wei per Brain (must equal `tokenIds.length`)\\n    /// @param reason   free-form bytes32, typically keccak256(promptHash) for\\n    ///                 off-chain attribution. Pass 0x0 if not needed.\\n    function distribute(uint256[] calldata tokenIds, uint256[] calldata amounts, bytes32 reason)\\n        external\\n        payable\\n        nonReentrant\\n    {\\n        if (tokenIds.length != amounts.length) revert Errors.LengthMismatch();\\n\\n        uint256 total;\\n        for (uint256 i; i < amounts.length; ++i) {\\n            total += amounts[i];\\n        }\\n        if (msg.value < total) revert Errors.InsufficientValue();\\n\\n        for (uint256 i; i < tokenIds.length; ++i) {\\n            address brainOwner = BRAIN.ownerOf(tokenIds[i]);\\n            pendingWithdrawals[brainOwner] += amounts[i];\\n            emit Distributed(tokenIds[i], brainOwner, msg.sender, amounts[i], reason);\\n        }\\n\\n        // Refund any surplus to msg.sender so over-pay doesn't get stuck.\\n        uint256 refund = msg.value - total;\\n        if (refund > 0) {\\n            (bool ok,) = msg.sender.call{ value: refund }(\\\"\\\");\\n            if (!ok) revert Errors.TransferFailed();\\n        }\\n    }\\n\\n    // ============ External: pull-payment withdrawal ============\\n\\n    /// @notice Brain owners pull their accumulated distribution credits.\\n    function withdraw() external nonReentrant {\\n        uint256 amount = pendingWithdrawals[msg.sender];\\n        if (amount == 0) revert Errors.ZeroAmount();\\n        pendingWithdrawals[msg.sender] = 0;\\n        (bool ok,) = msg.sender.call{ value: amount }(\\\"\\\");\\n        if (!ok) revert Errors.TransferFailed();\\n        emit WithdrawnByOwner(msg.sender, amount);\\n    }\\n}\\n\"},\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC-1967 implementation slot:\\n * ```solidity\\n * contract ERC1967 {\\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n *     function _getImplementation() internal view returns (address) {\\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n *     }\\n *\\n *     function _setImplementation(address newImplementation) internal {\\n *         require(newImplementation.code.length > 0);\\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n *     }\\n * }\\n * ```\\n *\\n * TIP: Consider using this library along with {SlotDerivation}.\\n */\\nlibrary StorageSlot {\\n    struct AddressSlot {\\n        address value;\\n    }\\n\\n    struct BooleanSlot {\\n        bool value;\\n    }\\n\\n    struct Bytes32Slot {\\n        bytes32 value;\\n    }\\n\\n    struct Uint256Slot {\\n        uint256 value;\\n    }\\n\\n    struct Int256Slot {\\n        int256 value;\\n    }\\n\\n    struct StringSlot {\\n        string value;\\n    }\\n\\n    struct BytesSlot {\\n        bytes value;\\n    }\\n\\n    /**\\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n     */\\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\\n     */\\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\\n     */\\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\\n     */\\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\\n     */\\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\\n     */\\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\\n     */\\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := store.slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\\n     */\\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\\n     */\\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := store.slot\\n        }\\n    }\\n}\\n\"},\"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {StorageSlot} from \\\"./StorageSlot.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\\n * consider using {ReentrancyGuardTransient} instead.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n *\\n * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced\\n * by the {ReentrancyGuardTransient} variant in v6.0.\\n *\\n * @custom:stateless\\n */\\nabstract contract ReentrancyGuard {\\n    using StorageSlot for bytes32;\\n\\n    // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.ReentrancyGuard\\\")) - 1)) & ~bytes32(uint256(0xff))\\n    bytes32 private constant REENTRANCY_GUARD_STORAGE =\\n        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;\\n\\n    // Booleans are more expensive than uint256 or any type that takes up a full\\n    // word because each write operation emits an extra SLOAD to first read the\\n    // slot's contents, replace the bits taken up by the boolean, and then write\\n    // back. This is the compiler's defense against contract upgrades and\\n    // pointer aliasing, and it cannot be disabled.\\n\\n    // The values being non-zero value makes deployment a bit more expensive,\\n    // but in exchange the refund on every call to nonReentrant will be lower in\\n    // amount. Since refunds are capped to a percentage of the total\\n    // transaction's gas, it is best to keep them low in cases like this one, to\\n    // increase the likelihood of the full refund coming into effect.\\n    uint256 private constant NOT_ENTERED = 1;\\n    uint256 private constant ENTERED = 2;\\n\\n    /**\\n     * @dev Unauthorized reentrant call.\\n     */\\n    error ReentrancyGuardReentrantCall();\\n\\n    constructor() {\\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev Prevents a contract from calling itself, directly or indirectly.\\n     * Calling a `nonReentrant` function from another `nonReentrant`\\n     * function is not supported. It is possible to prevent this from happening\\n     * by making the `nonReentrant` function external, and making it call a\\n     * `private` function that does the actual work.\\n     */\\n    modifier nonReentrant() {\\n        _nonReentrantBefore();\\n        _;\\n        _nonReentrantAfter();\\n    }\\n\\n    /**\\n     * @dev A `view` only version of {nonReentrant}. Use to block view functions\\n     * from being called, preventing reading from inconsistent contract state.\\n     *\\n     * CAUTION: This is a \\\"view\\\" modifier and does not change the reentrancy\\n     * status. Use it only on view functions. For payable or non-payable functions,\\n     * use the standard {nonReentrant} modifier instead.\\n     */\\n    modifier nonReentrantView() {\\n        _nonReentrantBeforeView();\\n        _;\\n    }\\n\\n    function _nonReentrantBeforeView() private view {\\n        if (_reentrancyGuardEntered()) {\\n            revert ReentrancyGuardReentrantCall();\\n        }\\n    }\\n\\n    function _nonReentrantBefore() private {\\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\\n        _nonReentrantBeforeView();\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;\\n    }\\n\\n    function _nonReentrantAfter() private {\\n        // By storing the original value once again, a refund is triggered (see\\n        // https://eips.ethereum.org/EIPS/eip-2200)\\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n     * `nonReentrant` function in the call stack.\\n     */\\n    function _reentrancyGuardEntered() internal view returns (bool) {\\n        return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;\\n    }\\n\\n    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {\\n        return REENTRANCY_GUARD_STORAGE;\\n    }\\n}\\n\"}},\"language\":\"Solidity\",\"settings\":{\"viaIR\":true,\"metadata\":{\"appendCBOR\":true,\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":false},\"libraries\":{},\"optimizer\":{\"runs\":200,\"enabled\":true},\"evmVersion\":\"cancun\",\"remappings\":[\"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\"ens-contracts/=lib/ens-contracts/contracts/\",\"forge-std/=lib/forge-std/src/\",\"erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\"halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\"openzeppelin-contracts/=lib/openzeppelin-contracts/\"]}}","verify":{"address":"net16661:ab7tvfm0yet6930tdu9d4hb0z88s6n2asp8uyxeycr","name":"src/RoyaltyDistributor.sol:RoyaltyDistributor","language":"solidity","sourceCode":"{\"sources\":{\"src/lib/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.30;\\n\\n// forgefmt: disable-start\\n//\\n//        ██████╗ ██████╗  █████╗ ██╗███╗   ██╗██████╗ ███████╗██████╗ ██╗ █████╗\\n//        ██╔══██╗██╔══██╗██╔══██╗██║████╗  ██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗\\n//        ██████╔╝██████╔╝███████║██║██╔██╗ ██║██████╔╝█████╗  ██║  ██║██║███████║\\n//        ██╔══██╗██╔══██╗██╔══██║██║██║╚██╗██║██╔═══╝ ██╔══╝  ██║  ██║██║██╔══██║\\n//        ██████╔╝██║  ██║██║  ██║██║██║ ╚████║██║     ███████╗██████╔╝██║██║  ██║\\n//        ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═╝     ╚══════╝╚═════╝ ╚═╝╚═╝  ╚═╝\\n//\\n//        Specialty AI Brains as iNFTs · Agent-paid knowledge marketplace\\n//\\n// forgefmt: disable-end\\n\\n/// @title  Errors\\n/// @author Brainpedia Team\\n/// @notice Custom errors used across the Brainpedia contract suite.\\n/// @dev    Library of error declarations. Replaces every `require(cond, \\\"string\\\")`\\n///         in Brain, BrainOracle, BrainMinter, RoyaltyDistributor, SubnameRegistrar,\\n///         and AccessTokenRegistrar. Custom errors are gas-efficient and fully\\n///         typed for off-chain decoding.\\nlibrary Errors {\\n    // ----- Generic input validation -----\\n\\n    /// @notice Thrown when an address parameter is the zero address.\\n    error ZeroAddress();\\n\\n    /// @notice Thrown when an amount parameter is zero.\\n    error ZeroAmount();\\n\\n    /// @notice Thrown when two arrays that must be the same length are not.\\n    error LengthMismatch();\\n\\n    /// @notice Thrown when a native ETH transfer fails.\\n    error EthTransferFailed();\\n\\n    /// @notice Thrown when ECDSA recovery does not return the configured signer.\\n    error InvalidSignature();\\n\\n    // ----- Brain (ERC-7857 iNFT) -----\\n\\n    /// @notice Thrown when `msg.sender` is not the owner of the targeted tokenId.\\n    error NotBrainOwner();\\n\\n    /// @notice Thrown when authorizeUsage is called with msg.value below the\\n    ///         Brain's configured per-query minimum payment.\\n    error InsufficientPayment();\\n\\n    /// @notice Thrown when the per-query payment forward from the Brain contract\\n    ///         to the Brain owner fails (e.g., recipient is a contract that reverts\\n    ///         on receive).\\n    error PaymentForwardFailed();\\n\\n    /// @notice Thrown when a view function is called on a tokenId that has no\\n    ///         IntelligentData records yet (i.e., was never minted or was burned).\\n    error NoIntelligence();\\n\\n    // ----- ERC-7857 canonical transfer path -----\\n\\n    /// @notice Thrown when a caller invokes `transferFrom` or `safeTransferFrom`\\n    ///         directly. ERC-7857 mandates the oracle-attested `secureTransfer`\\n    ///         path so that the per-Brain symmetric key can be re-sealed for the\\n    ///         new owner. Standard ERC-721 transfers would leave the recipient\\n    ///         with an undecryptable Brain.\\n    error UseSecureTransfer();\\n\\n    /// @notice Thrown when secureTransfer is called before an oracle is set.\\n    error OracleNotSet();\\n\\n    /// @notice Thrown when the configured oracle rejects the supplied proof.\\n    error InvalidOracleProof();\\n\\n    // ----- BrainOracle attestation -----\\n\\n    /// @notice Thrown when verifyProof is called while the attestor is unset.\\n    error AttestorNotSet();\\n\\n    /// @notice Thrown when the EIP-712 TransferAttestation deadline has passed.\\n    error AttestationExpired();\\n\\n    /// @notice Thrown when the supplied oracle proof is malformed (e.g., too\\n    ///         short to ABI-decode as a TransferAttestation).\\n    error InvalidProofFormat();\\n\\n    // ----- BrainMinter anti-spam -----\\n\\n    /// @notice Thrown when mintToSender is called with msg.value below the\\n    ///         currently-configured anti-spam mint fee.\\n    error InsufficientFee();\\n\\n    /// @notice Thrown when an internal native-token transfer fails (fee sweep,\\n    ///         payment forward, refund).\\n    error TransferFailed();\\n\\n    // ----- RoyaltyDistributor -----\\n\\n    /// @notice Thrown when distribute() is called with msg.value below the\\n    ///         sum of per-Brain payment amounts.\\n    error InsufficientValue();\\n\\n    // ----- ENS subname + access-token registrars -----\\n\\n    /// @notice Thrown when a registrar tries to issue a subname whose label\\n    ///         hash is already registered.\\n    error LabelAlreadyTaken();\\n\\n    /// @notice Thrown when a subname text-record write is attempted by an\\n    ///         account that does not own the label.\\n    error NotLabelOwner();\\n\\n    /// @notice Thrown when a non-issuer account calls a function gated by\\n    ///         the issuer allow-list on AccessTokenRegistrar.\\n    error NotIssuer();\\n\\n    /// @notice Thrown when an AccessTokenRegistrar operation references a\\n    ///         label that has never been issued.\\n    error TokenNotFound();\\n\\n    /// @notice Thrown when an AccessTokenRegistrar operation references a\\n    ///         label whose TTL has elapsed.\\n    error TokenExpired();\\n}\\n\"},\"src/RoyaltyDistributor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.30;\\n\\n// forgefmt: disable-start\\n//\\n//        ██████╗ ██████╗  █████╗ ██╗███╗   ██╗██████╗ ███████╗██████╗ ██╗ █████╗\\n//        ██╔══██╗██╔══██╗██╔══██╗██║████╗  ██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗\\n//        ██████╔╝██████╔╝███████║██║██╔██╗ ██║██████╔╝█████╗  ██║  ██║██║███████║\\n//        ██╔══██╗██╔══██╗██╔══██║██║██║╚██╗██║██╔═══╝ ██╔══╝  ██║  ██║██║██╔══██║\\n//        ██████╔╝██║  ██║██║  ██║██║██║ ╚████║██║     ███████╗██████╔╝██║██║  ██║\\n//        ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═╝     ╚══════╝╚═════╝ ╚═╝╚═╝  ╚═╝\\n//\\n//        Specialty AI Brains as iNFTs · Agent-paid knowledge marketplace\\n//\\n// forgefmt: disable-end\\n\\nimport { ReentrancyGuard } from \\\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\\\";\\n\\nimport { Errors } from \\\"./lib/Errors.sol\\\";\\n\\ninterface IERC721Owner {\\n    function ownerOf(uint256 tokenId) external view returns (address);\\n}\\n\\n/// @title  RoyaltyDistributor\\n/// @author Brainpedia Team\\n/// @notice Settles a multi-Brain query payment in a single transaction.\\n///         Takes a list of (tokenId, amount) pairs and credits each amount\\n///         to the corresponding Brain owner's pending balance for later\\n///         pull-collection.\\n/// @dev    Audit finding #3: pull-payment pattern prevents a reverting Brain\\n///         owner from DoS-ing the entire batch. Each (tokenId, amount) pair\\n///         increments `pendingWithdrawals[ownerOf(tokenId)]`. Brain owners\\n///         call `withdraw()` to collect. Surplus `msg.value` is refunded to\\n///         the caller at the end of `distribute`.\\ncontract RoyaltyDistributor is ReentrancyGuard {\\n    // ============ Immutables ============\\n\\n    IERC721Owner public immutable BRAIN;\\n\\n    // ============ Storage ============\\n\\n    /// @notice Brain owner → pending native payment balance (wei).\\n    mapping(address brainOwner => uint256 amount) public pendingWithdrawals;\\n\\n    // ============ Events ============\\n\\n    /// @notice Per-recipient distribution log.\\n    event Distributed(\\n        uint256 indexed tokenId,\\n        address indexed brainOwner,\\n        address indexed payer,\\n        uint256 amount,\\n        bytes32 reason\\n    );\\n    event WithdrawnByOwner(address indexed brainOwner, uint256 amount);\\n\\n    // ============ Constructor ============\\n\\n    constructor(address brain_) {\\n        if (brain_ == address(0)) revert Errors.ZeroAddress();\\n        BRAIN = IERC721Owner(brain_);\\n    }\\n\\n    // ============ External: distribute ============\\n\\n    /// @param tokenIds the Brain iNFTs to pay\\n    /// @param amounts  amount-in-wei per Brain (must equal `tokenIds.length`)\\n    /// @param reason   free-form bytes32, typically keccak256(promptHash) for\\n    ///                 off-chain attribution. Pass 0x0 if not needed.\\n    function distribute(uint256[] calldata tokenIds, uint256[] calldata amounts, bytes32 reason)\\n        external\\n        payable\\n        nonReentrant\\n    {\\n        if (tokenIds.length != amounts.length) revert Errors.LengthMismatch();\\n\\n        uint256 total;\\n        for (uint256 i; i < amounts.length; ++i) {\\n            total += amounts[i];\\n        }\\n        if (msg.value < total) revert Errors.InsufficientValue();\\n\\n        for (uint256 i; i < tokenIds.length; ++i) {\\n            address brainOwner = BRAIN.ownerOf(tokenIds[i]);\\n            pendingWithdrawals[brainOwner] += amounts[i];\\n            emit Distributed(tokenIds[i], brainOwner, msg.sender, amounts[i], reason);\\n        }\\n\\n        // Refund any surplus to msg.sender so over-pay doesn't get stuck.\\n        uint256 refund = msg.value - total;\\n        if (refund > 0) {\\n            (bool ok,) = msg.sender.call{ value: refund }(\\\"\\\");\\n            if (!ok) revert Errors.TransferFailed();\\n        }\\n    }\\n\\n    // ============ External: pull-payment withdrawal ============\\n\\n    /// @notice Brain owners pull their accumulated distribution credits.\\n    function withdraw() external nonReentrant {\\n        uint256 amount = pendingWithdrawals[msg.sender];\\n        if (amount == 0) revert Errors.ZeroAmount();\\n        pendingWithdrawals[msg.sender] = 0;\\n        (bool ok,) = msg.sender.call{ value: amount }(\\\"\\\");\\n        if (!ok) revert Errors.TransferFailed();\\n        emit WithdrawnByOwner(msg.sender, amount);\\n    }\\n}\\n\"},\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC-1967 implementation slot:\\n * ```solidity\\n * contract ERC1967 {\\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n *     function _getImplementation() internal view returns (address) {\\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n *     }\\n *\\n *     function _setImplementation(address newImplementation) internal {\\n *         require(newImplementation.code.length > 0);\\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n *     }\\n * }\\n * ```\\n *\\n * TIP: Consider using this library along with {SlotDerivation}.\\n */\\nlibrary StorageSlot {\\n    struct AddressSlot {\\n        address value;\\n    }\\n\\n    struct BooleanSlot {\\n        bool value;\\n    }\\n\\n    struct Bytes32Slot {\\n        bytes32 value;\\n    }\\n\\n    struct Uint256Slot {\\n        uint256 value;\\n    }\\n\\n    struct Int256Slot {\\n        int256 value;\\n    }\\n\\n    struct StringSlot {\\n        string value;\\n    }\\n\\n    struct BytesSlot {\\n        bytes value;\\n    }\\n\\n    /**\\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n     */\\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\\n     */\\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\\n     */\\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\\n     */\\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\\n     */\\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\\n     */\\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\\n     */\\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := store.slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\\n     */\\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\\n     */\\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := store.slot\\n        }\\n    }\\n}\\n\"},\"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {StorageSlot} from \\\"./StorageSlot.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\\n * consider using {ReentrancyGuardTransient} instead.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n *\\n * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced\\n * by the {ReentrancyGuardTransient} variant in v6.0.\\n *\\n * @custom:stateless\\n */\\nabstract contract ReentrancyGuard {\\n    using StorageSlot for bytes32;\\n\\n    // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.ReentrancyGuard\\\")) - 1)) & ~bytes32(uint256(0xff))\\n    bytes32 private constant REENTRANCY_GUARD_STORAGE =\\n        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;\\n\\n    // Booleans are more expensive than uint256 or any type that takes up a full\\n    // word because each write operation emits an extra SLOAD to first read the\\n    // slot's contents, replace the bits taken up by the boolean, and then write\\n    // back. This is the compiler's defense against contract upgrades and\\n    // pointer aliasing, and it cannot be disabled.\\n\\n    // The values being non-zero value makes deployment a bit more expensive,\\n    // but in exchange the refund on every call to nonReentrant will be lower in\\n    // amount. Since refunds are capped to a percentage of the total\\n    // transaction's gas, it is best to keep them low in cases like this one, to\\n    // increase the likelihood of the full refund coming into effect.\\n    uint256 private constant NOT_ENTERED = 1;\\n    uint256 private constant ENTERED = 2;\\n\\n    /**\\n     * @dev Unauthorized reentrant call.\\n     */\\n    error ReentrancyGuardReentrantCall();\\n\\n    constructor() {\\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev Prevents a contract from calling itself, directly or indirectly.\\n     * Calling a `nonReentrant` function from another `nonReentrant`\\n     * function is not supported. It is possible to prevent this from happening\\n     * by making the `nonReentrant` function external, and making it call a\\n     * `private` function that does the actual work.\\n     */\\n    modifier nonReentrant() {\\n        _nonReentrantBefore();\\n        _;\\n        _nonReentrantAfter();\\n    }\\n\\n    /**\\n     * @dev A `view` only version of {nonReentrant}. Use to block view functions\\n     * from being called, preventing reading from inconsistent contract state.\\n     *\\n     * CAUTION: This is a \\\"view\\\" modifier and does not change the reentrancy\\n     * status. Use it only on view functions. For payable or non-payable functions,\\n     * use the standard {nonReentrant} modifier instead.\\n     */\\n    modifier nonReentrantView() {\\n        _nonReentrantBeforeView();\\n        _;\\n    }\\n\\n    function _nonReentrantBeforeView() private view {\\n        if (_reentrancyGuardEntered()) {\\n            revert ReentrancyGuardReentrantCall();\\n        }\\n    }\\n\\n    function _nonReentrantBefore() private {\\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\\n        _nonReentrantBeforeView();\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;\\n    }\\n\\n    function _nonReentrantAfter() private {\\n        // By storing the original value once again, a refund is triggered (see\\n        // https://eips.ethereum.org/EIPS/eip-2200)\\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n     * `nonReentrant` function in the call stack.\\n     */\\n    function _reentrancyGuardEntered() internal view returns (bool) {\\n        return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;\\n    }\\n\\n    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {\\n        return REENTRANCY_GUARD_STORAGE;\\n    }\\n}\\n\"}},\"language\":\"Solidity\",\"settings\":{\"viaIR\":true,\"metadata\":{\"appendCBOR\":true,\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":false},\"libraries\":{},\"optimizer\":{\"runs\":200,\"enabled\":true},\"evmVersion\":\"cancun\",\"remappings\":[\"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\"ens-contracts/=lib/ens-contracts/contracts/\",\"forge-std/=lib/forge-std/src/\",\"erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\"halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\"openzeppelin-contracts/=lib/openzeppelin-contracts/\"]}}","abi":"[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"brain_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"name\":\"InsufficientValue\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"LengthMismatch\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"TransferFailed\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"ZeroAddress\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"ZeroAmount\",\"type\":\"error\",\"inputs\":[]},{\"name\":\"Distributed\",\"type\":\"event\",\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"brainOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"payer\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"reason\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"name\":\"WithdrawnByOwner\",\"type\":\"event\",\"inputs\":[{\"name\":\"brainOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"name\":\"BRAIN\",\"type\":\"function\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contract IERC721Owner\"}],\"stateMutability\":\"view\"},{\"name\":\"distribute\",\"type\":\"function\",\"inputs\":[{\"name\":\"tokenIds\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"amounts\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"reason\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"name\":\"pendingWithdrawals\",\"type\":\"function\",\"inputs\":[{\"name\":\"brainOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"name\":\"withdraw\",\"type\":\"function\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"}]","version":"0.8.30+commit.73712a01","evmVersion":"cancun","optimization":1,"runs":200,"libraries":[],"license":"None","constructorArgs":"0x0000000000000000000000008c2be2d73876ec7bd8a190f3317f3c6ca91d66d6","similarMatchAddress":null,"exactMatch":true,"similarMatchNetworkId":null,"crossSpace":false},"proxy":{},"beacon":{"verify":{}},"implementation":{"verify":{}},"destroy":{"status":0,"message":"deployed"},"isRegistered":true,"accountInfo":{"total":0,"map":{}}}}